cadwyn 3.11.1__py3-none-any.whl → 3.15.10__py3-none-any.whl

cadwyn/__init__.py

@@ -2,8 +2,12 @@ import importlib.metadata
 
 from .applications import Cadwyn
 from .codegen import generate_code_for_versioned_packages
-from .route_generation import InternalRepresentationOf, VersionedAPIRouter, generate_versioned_routers
-from .structure import VersionBundle
+from .route_generation import (
+    InternalRepresentationOf,  # pyright: ignore[reportDeprecated]
+    VersionedAPIRouter,
+    generate_versioned_routers,
+)
+from .structure import HeadVersion, Version, VersionBundle
 
 __version__ = importlib.metadata.version("cadwyn")
 __all__ = [
@@ -11,6 +15,8 @@ __all__ = [
     "VersionedAPIRouter",
     "generate_code_for_versioned_packages",
     "VersionBundle",
+    "HeadVersion",
+    "Version",
     "generate_versioned_routers",
     "InternalRepresentationOf",
 ]

cadwyn/__main__.py

@@ -60,7 +60,7 @@ def deprecated_generate_versioned_packages(
     possibly_version_bundle = getattr(version_bundle_module, version_bundle_variable_name)
     version_bundle = _get_version_bundle(possibly_version_bundle)
 
-    return generate_code_for_versioned_packages(
+    return generate_code_for_versioned_packages(  # pyright: ignore[reportDeprecated]
         template_package,
         version_bundle,
         ignore_coverage_for_latest_aliases=ignore_coverage_for_latest_aliases,
@@ -115,8 +115,7 @@ def _get_version_bundle(possibly_version_bundle: Any) -> VersionBundle:
 @app.callback()
 def main(
     version: bool = typer.Option(None, "-V", "--version", callback=version_callback, is_eager=True),
-):
-    ...
+): ...
 
 
 if __name__ == "__main__":

cadwyn/_asts.py

@@ -10,6 +10,7 @@ from typing import (  # noqa: UP035
     TYPE_CHECKING,
     Any,
     List,
+    cast,
     get_args,
     get_origin,
 )
@@ -32,7 +33,7 @@ _RE_CAMEL_TO_SNAKE = re.compile(r"(?<!^)(?=[A-Z])")
 
 
 # A parent type of typing._GenericAlias
-_BaseGenericAlias = type(List[int]).mro()[1]  # noqa: UP006
+_BaseGenericAlias = cast(type, type(List[int])).mro()[1]  # noqa: UP006
 
 # type(list[int]) and type(List[int]) are different which is why we have to do this.
 # Please note that this problem is much wider than just lists which is why we use typing._BaseGenericAlias
@@ -100,7 +101,7 @@ def transform_generic_alias(value: GenericAliasUnion) -> Any:
     return f"{get_fancy_repr(get_origin(value))}[{', '.join(get_fancy_repr(a) for a in get_args(value))}]"
 
 
-def transform_none(_: NoneType) -> Any:
+def transform_none(_: Any) -> Any:
     return "None"
 
 
@@ -134,7 +135,7 @@ def transform_auto(_: auto) -> Any:
     return PlainRepr("auto()")
 
 
-def transform_union(value: UnionType) -> Any:  # pyright: ignore[reportInvalidTypeForm]
+def transform_union(value: UnionType) -> Any:
     return "typing.Union[" + (", ".join(get_fancy_repr(a) for a in get_args(value))) + "]"
 
 
@@ -155,7 +156,6 @@ def transform_other(value: Any) -> Any:
 def _get_lambda_source_from_default_factory(source: str) -> str:
     found_lambdas: list[ast.Lambda] = []
 
-    ast.parse(source)
     for node in ast.walk(ast.parse(source)):
         if isinstance(node, ast.keyword) and node.arg == "default_factory" and isinstance(node.value, ast.Lambda):
             found_lambdas.append(node.value)
@@ -231,7 +231,7 @@ def delete_keyword_from_call(attr_name: str, call: ast.Call):
 def get_ast_keyword_from_argument_name_and_value(name: str, value: Any):
     if not isinstance(value, ast.AST):
         value = ast.parse(get_fancy_repr(value), mode="eval").body
-    return ast.keyword(arg=name, value=value)
+    return ast.keyword(arg=name, value=value)  # pyright: ignore[reportArgumentType, reportCallIssue]
 
 
 def pop_docstring_from_cls_body(cls_body: list[ast.stmt]) -> list[ast.stmt]:

cadwyn/_compat.py

@@ -61,7 +61,7 @@ class PydanticFieldWrapper:
 
     annotation: Any
 
-    init_model_field: dataclasses.InitVar[ModelField]  # pyright: ignore[reportInvalidTypeForm]
+    init_model_field: dataclasses.InitVar[ModelField]
     field_info: FieldInfo = dataclasses.field(init=False)
 
     annotation_ast: ast.expr | None = None
@@ -69,7 +69,7 @@ class PydanticFieldWrapper:
     # the value_ast is "None" and "Field(default=None)" respectively
     value_ast: ast.expr | None = None
 
-    def __post_init__(self, init_model_field: ModelField):  # pyright: ignore[reportInvalidTypeForm]
+    def __post_init__(self, init_model_field: ModelField):
         if isinstance(init_model_field, FieldInfo):
             self.field_info = init_model_field
         else:
@@ -111,6 +111,13 @@ class PydanticFieldWrapper:
             return attributes | extras
 
 
+def get_annotation_from_model_field(model: ModelField) -> Any:
+    if PYDANTIC_V2:
+        return model.field_info.annotation
+    else:
+        return model.annotation
+
+
 def model_fields(model: type[BaseModel]) -> dict[str, FieldInfo]:
     if PYDANTIC_V2:
         return model.model_fields

cadwyn/applications.py

@@ -1,3 +1,5 @@
+import dataclasses
+import datetime
 from collections.abc import Callable, Coroutine, Sequence
 from datetime import date
 from logging import getLogger
@@ -7,9 +9,14 @@ from typing import Any, cast
 
 from fastapi import APIRouter, FastAPI, HTTPException, routing
 from fastapi.datastructures import Default
-from fastapi.openapi.docs import get_redoc_html, get_swagger_ui_html
+from fastapi.openapi.docs import (
+    get_redoc_html,
+    get_swagger_ui_html,
+    get_swagger_ui_oauth2_redirect_html,
+)
 from fastapi.openapi.utils import get_openapi
 from fastapi.params import Depends
+from fastapi.responses import HTMLResponse
 from fastapi.templating import Jinja2Templates
 from fastapi.utils import generate_unique_id
 from starlette.middleware import Middleware
@@ -28,6 +35,11 @@ CURR_DIR = Path(__file__).resolve()
 logger = getLogger(__name__)
 
 
+@dataclasses.dataclass(slots=True)
+class FakeDependencyOverridesProvider:
+    dependency_overrides: dict[Callable[..., Any], Callable[..., Any]]
+
+
 class Cadwyn(FastAPI):
     _templates = Jinja2Templates(directory=CURR_DIR.parent / "static")
 
@@ -53,8 +65,13 @@ class Cadwyn(FastAPI):
         swagger_ui_oauth2_redirect_url: str | None = "/docs/oauth2-redirect",
         swagger_ui_init_oauth: dict[str, Any] | None = None,
         middleware: Sequence[Middleware] | None = None,
-        exception_handlers: dict[int | type[Exception], Callable[[Request, Any], Coroutine[Any, Any, Response]]]
-        | None = None,
+        exception_handlers: (
+            dict[
+                int | type[Exception],
+                Callable[[Request, Any], Coroutine[Any, Any, Response]],
+            ]
+            | None
+        ) = None,
         on_startup: Sequence[Callable[[], Any]] | None = None,
         on_shutdown: Sequence[Callable[[], Any]] | None = None,
         lifespan: Lifespan[Self] | None = None,
@@ -70,7 +87,9 @@ class Cadwyn(FastAPI):
         deprecated: bool | None = None,
         include_in_schema: bool = True,
         swagger_ui_parameters: dict[str, Any] | None = None,
-        generate_unique_id_function: Callable[[routing.APIRoute], str] = Default(generate_unique_id),  # noqa: B008
+        generate_unique_id_function: Callable[[routing.APIRoute], str] = Default(  # noqa: B008
+            generate_unique_id
+        ),
         separate_input_output_schemas: bool = True,
         **extra: Any,
     ) -> None:
@@ -79,6 +98,7 @@ class Cadwyn(FastAPI):
         latest_schemas_package = extra.pop("latest_schemas_package", None) or self.versions.head_schemas_package
         self.versions.head_schemas_package = latest_schemas_package
         self._latest_schemas_package = cast(ModuleType, latest_schemas_package)
+        self._dependency_overrides_provider = FakeDependencyOverridesProvider({})
 
         super().__init__(
             debug=debug,
@@ -117,28 +137,35 @@ class Cadwyn(FastAPI):
             separate_input_output_schemas=separate_input_output_schemas,
             **extra,
         )
+        self._kwargs_to_router: dict[str, Any] = {
+            "routes": routes,
+            "redirect_slashes": redirect_slashes,
+            "dependency_overrides_provider": self,
+            "on_startup": on_startup,
+            "on_shutdown": on_shutdown,
+            "lifespan": lifespan,
+            "default_response_class": default_response_class,
+            "dependencies": dependencies,
+            "callbacks": callbacks,
+            "deprecated": deprecated,
+            "include_in_schema": include_in_schema,
+            "responses": responses,
+            "generate_unique_id_function": generate_unique_id_function,
+        }
         self.router: _RootHeaderAPIRouter = _RootHeaderAPIRouter(  # pyright: ignore[reportIncompatibleVariableOverride]
-            routes=self.routes,
-            on_startup=on_startup,
-            on_shutdown=on_shutdown,
-            default_response_class=default_response_class,
-            dependencies=dependencies,
-            callbacks=callbacks,
-            deprecated=deprecated,
-            responses=responses,
+            **self._kwargs_to_router,
             api_version_header_name=api_version_header_name,
             api_version_var=self.versions.api_version_var,
-            lifespan=lifespan,
         )
+
         self.docs_url = docs_url
         self.redoc_url = redoc_url
         self.openapi_url = openapi_url
         self.redoc_url = redoc_url
-        self.swaggers = {}
 
-        unversioned_router = APIRouter(routes=routes)
+        unversioned_router = APIRouter(**self._kwargs_to_router)
         self._add_openapi_endpoints(unversioned_router)
-        self.add_unversioned_routers(unversioned_router)
+        self.include_router(unversioned_router)
         self.add_middleware(
             HeaderVersioningMiddleware,
             api_version_header_name=self.router.api_version_header_name,
@@ -146,6 +173,20 @@ class Cadwyn(FastAPI):
             default_response_class=default_response_class,
         )
 
+    @property
+    def dependency_overrides(self) -> dict[Callable[..., Any], Callable[..., Any]]:
+        # This is only necessary because we cannot send self to versioned router generator
+        # because it takes a deepcopy of the router and self.versions.head_schemas_package is a module
+        # which cannot be copied.
+        return self._dependency_overrides_provider.dependency_overrides
+
+    @dependency_overrides.setter
+    def dependency_overrides(  # pyright: ignore[reportIncompatibleVariableOverride]
+        self,
+        value: dict[Callable[..., Any], Callable[..., Any]],
+    ) -> None:
+        self._dependency_overrides_provider.dependency_overrides = value
+
     @property  # pragma: no cover
     @deprecated("It is going to be deleted in the future. Use VersionBundle.head_schemas_package instead")
     def latest_schemas_package(self):
@@ -169,6 +210,18 @@ class Cadwyn(FastAPI):
                     endpoint=self.swagger_dashboard,
                     include_in_schema=False,
                 )
+                if self.swagger_ui_oauth2_redirect_url:
+
+                    async def swagger_ui_redirect(req: Request) -> HTMLResponse:
+                        return (
+                            get_swagger_ui_oauth2_redirect_html()  # pragma: no cover # unimportant right now but # TODO
+                        )
+
+                    self.add_route(
+                        self.swagger_ui_oauth2_redirect_url,
+                        swagger_ui_redirect,
+                        include_in_schema=False,
+                    )
             if self.redoc_url is not None:
                 unversioned_router.add_route(
                     path=self.redoc_url,
@@ -177,7 +230,7 @@ class Cadwyn(FastAPI):
                 )
 
     def generate_and_include_versioned_routers(self, *routers: APIRouter) -> None:
-        root_router = APIRouter()
+        root_router = APIRouter(dependency_overrides_provider=self._dependency_overrides_provider)
         for router in routers:
             root_router.include_router(router)
         router_versions = generate_versioned_routers(
@@ -187,33 +240,32 @@ class Cadwyn(FastAPI):
         for version, router in router_versions.items():
             self.add_header_versioned_routers(router, header_value=version.isoformat())
 
-    def enrich_swagger(self):
-        """
-        This method goes through all header-based apps and collect a dict[openapi_version, openapi_json]
-
-        For each route a `X-API-VERSION` header with value is added
-
-        """
-        unversioned_routes_openapi = get_openapi(
-            title=self.title,
-            version=self.version,
-            openapi_version=self.openapi_version,
-            description=self.description,
-            terms_of_service=self.terms_of_service,
-            contact=self.contact,
-            license_info=self.license_info,
-            routes=self.router.unversioned_routes,
-            tags=self.openapi_tags,
-            servers=self.servers,
+    async def openapi_jsons(self, req: Request) -> JSONResponse:
+        raw_version = req.query_params.get("version") or req.headers.get(self.router.api_version_header_name)
+        not_found_error = HTTPException(
+            status_code=404,
+            detail=f"OpenApi file of with version `{raw_version}` not found",
         )
-        if unversioned_routes_openapi["paths"]:
-            self.swaggers["unversioned"] = unversioned_routes_openapi
+        try:
+            version = datetime.date.fromisoformat(raw_version)  # pyright: ignore[reportArgumentType]
+        # TypeError when raw_version is None
+        # ValueError when raw_version is of the non-iso format
+        except (ValueError, TypeError):
+            version = raw_version
+
+        if version in self.router.versioned_routers:
+            routes = self.router.versioned_routers[version].routes
+            formatted_version = version.isoformat()
+        elif version == "unversioned" and self._there_are_public_unversioned_routes():
+            routes = self.router.unversioned_routes
+            formatted_version = "unversioned"
+        else:
+            raise not_found_error
 
-        for header_value, routes in self.router.versioned_routes.items():
-            header_value_str = header_value.isoformat()
-            openapi = get_openapi(
+        return JSONResponse(
+            get_openapi(
                 title=self.title,
-                version=self.version,
+                version=formatted_version,
                 openapi_version=self.openapi_version,
                 description=self.description,
                 terms_of_service=self.terms_of_service,
@@ -223,41 +275,50 @@ class Cadwyn(FastAPI):
                 tags=self.openapi_tags,
                 servers=self.servers,
             )
-            # in current implementation we expect header_value to be a date
-            self.swaggers[header_value_str] = openapi
-
-    async def openapi_jsons(self, req: Request) -> JSONResponse:
-        version = req.query_params.get("version") or req.headers.get(self.router.api_version_header_name)
-        openapi_of_a_version = self.swaggers.get(version)
-        if not openapi_of_a_version:
-            raise HTTPException(
-                status_code=404,
-                detail=f"OpenApi file of with version `{version}` not found",
-            )
+        )
 
-        return JSONResponse(openapi_of_a_version)
+    def _there_are_public_unversioned_routes(self):
+        return any(isinstance(route, Route) and route.include_in_schema for route in self.router.unversioned_routes)
 
     async def swagger_dashboard(self, req: Request) -> Response:
-        return self._render_docs_dashboard_or_concrete_verssion(get_swagger_ui_html, req, cast(str, self.docs_url))
+        version = req.query_params.get("version")
 
-    async def redoc_dashboard(self, req: Request) -> Response:
-        return self._render_docs_dashboard_or_concrete_verssion(get_redoc_html, req, cast(str, self.redoc_url))
+        if version:
+            root_path = self._extract_root_path(req)
+            openapi_url = root_path + f"{self.openapi_url}?version={version}"
+            oauth2_redirect_url = self.swagger_ui_oauth2_redirect_url
+            if oauth2_redirect_url:
+                oauth2_redirect_url = root_path + oauth2_redirect_url
+            return get_swagger_ui_html(
+                openapi_url=openapi_url,
+                title=f"{self.title} - Swagger UI",
+                oauth2_redirect_url=oauth2_redirect_url,
+                init_oauth=self.swagger_ui_init_oauth,
+                swagger_ui_parameters=self.swagger_ui_parameters,
+            )
+        return self._render_docs_dashboard(req, cast(str, self.docs_url))
 
-    def _render_docs_dashboard_or_concrete_verssion(self, render_docs: Callable[..., Any], req: Request, docs_url: str):
-        base_url = str(req.base_url).rstrip("/")
+    async def redoc_dashboard(self, req: Request) -> Response:
         version = req.query_params.get("version")
 
         if version:
-            return render_docs(
-                openapi_url=f"{self.openapi_url}?version={version}",
-                title="Swagger UI",
-            )
+            root_path = self._extract_root_path(req)
+            openapi_url = root_path + f"{self.openapi_url}?version={version}"
+            return get_redoc_html(openapi_url=openapi_url, title=f"{self.title} - ReDoc")
+
+        return self._render_docs_dashboard(req, docs_url=cast(str, self.redoc_url))
+
+    def _extract_root_path(self, req: Request):
+        return req.scope.get("root_path", "").rstrip("/")
+
+    def _render_docs_dashboard(self, req: Request, docs_url: str):
+        base_url = str(req.base_url).rstrip("/")
+        table = {version: f"{base_url}{docs_url}?version={version}" for version in self.router.sorted_versions}
+        if self._there_are_public_unversioned_routes():
+            table |= {"unversioned": f"{base_url}{docs_url}?version=unversioned"}
         return self._templates.TemplateResponse(
             "docs.html",
-            {
-                "request": req,
-                "table": {version: f"{base_url}{docs_url}?version={version}" for version in sorted(self.swaggers)},
-            },
+            {"request": req, "table": table},
         )
 
     def add_header_versioned_routers(
@@ -272,33 +333,41 @@ class Cadwyn(FastAPI):
         except ValueError as e:
             raise ValueError("header_value should be in ISO 8601 format") from e
 
-        if header_value_as_dt not in self.router.versioned_routes:  # pragma: no branch
-            self.router.versioned_routes[header_value_as_dt] = []
-            if self.openapi_url is not None:  # pragma: no branch
-                self.router.versioned_routes[header_value_as_dt].append(
-                    Route(path=self.openapi_url, endpoint=self.openapi_jsons, include_in_schema=False)
-                )
-
         added_routes: list[BaseRoute] = []
-        for router in (first_router, *other_routers):
-            added_route_count = len(router.routes)
+        if header_value_as_dt not in self.router.versioned_routers:  # pragma: no branch
+            self.router.versioned_routers[header_value_as_dt] = APIRouter(**self._kwargs_to_router)
 
-            self.include_router(
+        versioned_router = self.router.versioned_routers[header_value_as_dt]
+        if self.openapi_url is not None:  # pragma: no branch
+            versioned_router.add_route(
+                path=self.openapi_url,
+                endpoint=self.openapi_jsons,
+                include_in_schema=False,
+            )
+            added_routes.append(versioned_router.routes[-1])
+
+        added_route_count = 0
+        for router in (first_router, *other_routers):
+            self.router.versioned_routers[header_value_as_dt].include_router(
                 router,
                 dependencies=[Depends(_get_api_version_dependency(self.router.api_version_header_name, header_value))],
             )
-            added_routes.extend(self.routes[len(self.routes) - added_route_count :])
-        for route in added_routes:
-            self.router.versioned_routes[header_value_as_dt].append(route)
+            added_route_count += len(router.routes)
+
+        added_routes.extend(versioned_router.routes[-added_route_count:])
+        self.router.routes.extend(added_routes)
 
-        self.enrich_swagger()
         return added_routes
 
+    @deprecated("Use builtin FastAPI methods such as include_router instead")
     def add_unversioned_routers(self, *routers: APIRouter):
         for router in routers:
             self.include_router(router)
-            self.router.unversioned_routes.extend(router.routes)
-        self.enrich_swagger()
 
+    @deprecated("Use builtin FastAPI methods such as add_api_route instead")
     def add_unversioned_routes(self, *routes: Route):
-        self.router.unversioned_routes.extend(routes)
+        router = APIRouter(routes=list(routes))
+        self.include_router(router)
+
+    @deprecated("It no longer does anything")
+    def enrich_swagger(self): ...

cadwyn/codegen/_common.py

@@ -1,6 +1,7 @@
 import ast
 import dataclasses
 import inspect
+import textwrap
 from dataclasses import dataclass
 from enum import Enum
 from functools import cache
@@ -89,7 +90,7 @@ def get_fields_and_validators_from_model(
             {},
         )
     else:
-        cls_ast = cast(ast.ClassDef, ast.parse(source).body[0])
+        cls_ast = cast(ast.ClassDef, ast.parse(textwrap.dedent(source)).body[0])
         validators: dict[str, _ValidatorWrapper] = {}
 
         validators_and_nones = (

cadwyn/codegen/_main.py

@@ -53,8 +53,7 @@ def generate_code_for_versioned_packages(
     codegen_plugins: Sequence[CodegenPlugin] = DEFAULT_CODEGEN_PLUGINS,
     migration_plugins: Sequence[MigrationPlugin] = DEFAULT_CODEGEN_MIGRATION_PLUGINS,
     extra_context: dict[str, Any] | None = None,
-):
-    ...
+): ...
 
 
 @overload
@@ -70,8 +69,7 @@ def generate_code_for_versioned_packages(
     codegen_plugins: Sequence[CodegenPlugin] = DEFAULT_CODEGEN_PLUGINS,
     migration_plugins: Sequence[MigrationPlugin] = DEFAULT_CODEGEN_MIGRATION_PLUGINS,
     extra_context: dict[str, Any] | None = None,
-):
-    ...
+): ...
 
 
 def generate_code_for_versioned_packages(
@@ -168,7 +166,7 @@ def _generate_directory_for_version(
         version_dir,
     ):
         file_source = read_python_module(template_module)
-        parsed_file = ast.parse(file_source)
+        parsed_file = ast_comments.parse(file_source)
         context = _build_context(global_context, template_dir, version_dir, template_module, parallel_file, parsed_file)
 
         parsed_file = _apply_module_level_plugins(plugins, parsed_file, context)
@@ -178,9 +176,9 @@ def _generate_directory_for_version(
 
 def _apply_module_level_plugins(
     plugins: Collection[CodegenPlugin],
-    parsed_file: ast.Module,
+    parsed_file: ast_comments.Module,
     context: CodegenContext,
-) -> ast.Module:
+) -> ast_comments.Module:
     node_type = type(parsed_file)
     for plugin in plugins:
         if issubclass(node_type, plugin.node_type):
@@ -190,9 +188,9 @@ def _apply_module_level_plugins(
 
 def _apply_per_node_plugins(
     plugins: Collection[CodegenPlugin],
-    parsed_file: ast.Module,
+    parsed_file: ast_comments.Module,
     context: CodegenContext,
-) -> ast.Module:
+) -> ast_comments.Module:
     new_body = []
 
     for node in parsed_file.body:
@@ -202,7 +200,7 @@ def _apply_per_node_plugins(
                 node = plugin(node, context)  # noqa: PLW2901
         new_body.append(node)
 
-    return ast.Module(body=new_body, type_ignores=[])
+    return ast_comments.Module(body=new_body, type_ignores=[])
 
 
 def _build_context(
@@ -211,7 +209,7 @@ def _build_context(
     version_dir: Path,
     template_module: ModuleType,
     parallel_file: Path,
-    parsed_file: ast.Module,
+    parsed_file: ast_comments.Module,
 ):
     if template_module.__name__.endswith(".__init__"):
         module_python_path = template_module.__name__.removesuffix(".__init__")

cadwyn/codegen/_plugins/class_rebuilding.py

@@ -80,9 +80,9 @@ def _modify_schema_cls(
     cls_node.name = model_info.name
 
     field_definitions = [
-        ast.AnnAssign(
+        ast.AnnAssign(  # pyright: ignore[reportCallIssue]
             target=ast.Name(name, ctx=ast.Store()),
-            annotation=copy.deepcopy(field.annotation_ast),
+            annotation=copy.deepcopy(field.annotation_ast),  # pyright: ignore[reportArgumentType]
             # We do this because next plugins **might** use a transformer which will edit the ast within the field
             # and break rendering
             value=copy.deepcopy(field.value_ast),

cadwyn/exceptions.py

@@ -46,6 +46,18 @@ class RouterPathParamsModifiedError(RouterGenerationError):
     pass
 
 
+class RouteResponseBySchemaConverterDoesNotApplyToAnythingError(RouterGenerationError):
+    pass
+
+
+class RouteRequestBySchemaConverterDoesNotApplyToAnythingError(RouterGenerationError):
+    pass
+
+
+class RouteByPathConverterDoesNotApplyToAnythingError(RouterGenerationError):
+    pass
+
+
 class RouteAlreadyExistsError(RouterGenerationError):
     def __init__(self, *routes: APIRoute):
         self.routes = routes

cadwyn/middleware.py

@@ -64,11 +64,11 @@ class HeaderVersioningMiddleware(BaseHTTPMiddleware):
                     request=request,
                     dependant=self.version_header_validation_dependant,
                     async_exit_stack=async_exit_stack,
+                    embed_body_fields=False,
                 )
-                values, errors, *_ = solved_result
-                if errors:
-                    return self.default_response_class(status_code=422, content=_normalize_errors(errors))
-                api_version = cast(date, values[self.api_version_header_name.replace("-", "_")])
+                if solved_result.errors:
+                    return self.default_response_class(status_code=422, content=_normalize_errors(solved_result.errors))
+                api_version = cast(date, solved_result.values[self.api_version_header_name.replace("-", "_")])
                 self.api_version_var.set(api_version)
 
         response = await call_next(request)