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

cadwyn/route_generation.py

@@ -12,10 +12,10 @@ from enum import Enum
 from pathlib import Path
 from types import GenericAlias, MappingProxyType, ModuleType
 from typing import (
+    TYPE_CHECKING,
     Annotated,
     Any,
     Generic,
-    TypeAlias,
     TypeVar,
     _BaseGenericAlias,  # pyright: ignore[reportAttributeAccessIssue]
     cast,
@@ -29,29 +29,25 @@ import fastapi.params
 import fastapi.routing
 import fastapi.security.base
 import fastapi.utils
+from fastapi import APIRouter
 from fastapi._compat import ModelField as FastAPIModelField
 from fastapi._compat import create_body_model
-from fastapi.dependencies.models import Dependant
-from fastapi.dependencies.utils import (
-    get_body_field,
-    get_dependant,
-    get_parameterless_sub_dependant,
-)
 from fastapi.params import Depends
 from fastapi.routing import APIRoute
+from issubclass import issubclass as lenient_issubclass
 from pydantic import BaseModel
-from starlette.routing import (
-    BaseRoute,
-    request_response,
-)
+from starlette.routing import BaseRoute
 from typing_extensions import Self, assert_never, deprecated
 
-from cadwyn._compat import model_fields, rebuild_fastapi_body_param
+from cadwyn._compat import get_annotation_from_model_field, model_fields, rebuild_fastapi_body_param
 from cadwyn._package_utils import get_version_dir_path
 from cadwyn._utils import Sentinel, UnionType, get_another_version_of_cls
 from cadwyn.exceptions import (
     CadwynError,
     RouteAlreadyExistsError,
+    RouteByPathConverterDoesNotApplyToAnythingError,
+    RouteRequestBySchemaConverterDoesNotApplyToAnythingError,
+    RouteResponseBySchemaConverterDoesNotApplyToAnythingError,
     RouterGenerationError,
     RouterPathParamsModifiedError,
 )
@@ -64,12 +60,13 @@ from cadwyn.structure.endpoints import (
 )
 from cadwyn.structure.versions import _CADWYN_REQUEST_PARAM_NAME, _CADWYN_RESPONSE_PARAM_NAME, VersionChange
 
-_T = TypeVar("_T", bound=Callable[..., Any])
+if TYPE_CHECKING:
+    from fastapi.dependencies.models import Dependant
+
+_Call = TypeVar("_Call", bound=Callable[..., Any])
 _R = TypeVar("_R", bound=fastapi.routing.APIRouter)
 # This is a hack we do because we can't guarantee how the user will use the router.
 _DELETED_ROUTE_TAG = "_CADWYN_DELETED_ROUTE"
-_EndpointPath: TypeAlias = str
-_EndpointMethod: TypeAlias = str
 
 
 @dataclass(slots=True, frozen=True, eq=True)
@@ -78,13 +75,6 @@ class _EndpointInfo:
     endpoint_methods: frozenset[str]
 
 
-@dataclass(slots=True)
-class _RouterInfo(Generic[_R]):
-    router: _R
-    routes_with_migrated_requests: dict[_EndpointPath, set[_EndpointMethod]]
-    route_bodies_with_migrated_requests: set[type[BaseModel]]
-
-
 @deprecated("It will soon be deleted. Use HeadVersion version changes instead.")
 class InternalRepresentationOf:
     def __class_getitem__(cls, original_schema: type, /) -> type[Self]:
@@ -95,8 +85,7 @@ class InternalRepresentationOf:
 def generate_versioned_routers(
     router: _R,
     versions: VersionBundle,
-) -> dict[VersionDate, _R]:
-    ...
+) -> dict[VersionDate, _R]: ...
 
 
 @overload
@@ -105,8 +94,7 @@ def generate_versioned_routers(
     router: _R,
     versions: VersionBundle,
     latest_schemas_package: ModuleType | None,
-) -> dict[VersionDate, _R]:
-    ...
+) -> dict[VersionDate, _R]: ...
 
 
 def generate_versioned_routers(
@@ -129,7 +117,7 @@ def generate_versioned_routers(
 
 
 class VersionedAPIRouter(fastapi.routing.APIRouter):
-    def only_exists_in_older_versions(self, endpoint: _T) -> _T:
+    def only_exists_in_older_versions(self, endpoint: _Call) -> _Call:
         route = _get_route_from_func(self.routes, endpoint)
         if route is None:
             raise LookupError(
@@ -163,22 +151,15 @@ class _EndpointTransformer(Generic[_R]):
             self.parent_router
         )
         router = deepcopy(self.parent_router)
-        router_infos: dict[VersionDate, _RouterInfo] = {}
-        routes_with_migrated_requests = {}
-        route_bodies_with_migrated_requests: set[type[BaseModel]] = set()
+        routers: dict[VersionDate, _R] = {}
+
         for version in self.versions:
             self.annotation_transformer.migrate_router_to_version(router, version)
 
-            router_infos[version.value] = _RouterInfo(
-                router,
-                routes_with_migrated_requests,
-                route_bodies_with_migrated_requests,
-            )
+            self._validate_all_data_converters_are_applied(router, version)
+
+            routers[version.value] = router
             # Applying changes for the next version
-            routes_with_migrated_requests = _get_migrated_routes_by_path(version)
-            route_bodies_with_migrated_requests = {
-                schema for change in version.version_changes for schema in change.alter_request_by_schema_instructions
-            }
             router = deepcopy(router)
             self._apply_endpoint_changes_to_router(router, version)
 
@@ -196,21 +177,21 @@ class _EndpointTransformer(Generic[_R]):
                 continue
             _add_request_and_response_params(head_route)
             copy_of_dependant = deepcopy(head_route.dependant)
-            # Remember this: if len(body_params) == 1, then route.body_schema == route.dependant.body_params[0]
-            if len(copy_of_dependant.body_params) == 1:
+
+            if _route_has_a_simple_body_schema(head_route):
                 self._replace_internal_representation_with_the_versioned_schema(
                     copy_of_dependant,
                     schema_to_internal_request_body_representation,
                 )
 
-            for older_router_info in list(router_infos.values()):
-                older_route = older_router_info.router.routes[route_index]
+            for older_router in list(routers.values()):
+                older_route = older_router.routes[route_index]
 
                 # We know they are APIRoutes because of the check at the very beginning of the top loop.
                 # I.e. Because head_route is an APIRoute, both routes are  APIRoutes too
                 older_route = cast(APIRoute, older_route)
                 # Wait.. Why do we need this code again?
-                if older_route.body_field is not None and len(older_route.dependant.body_params) == 1:
+                if older_route.body_field is not None and _route_has_a_simple_body_schema(older_route):
                     template_older_body_model = self.annotation_transformer._change_version_of_annotations(
                         older_route.body_field.type_,
                         self.annotation_transformer.head_version_dir,
@@ -226,17 +207,103 @@ class _EndpointTransformer(Generic[_R]):
                     copy_of_dependant,
                     self.versions,
                 )
-        for _, router_info in router_infos.items():
-            router_info.router.routes = [
+        for _, router in routers.items():
+            router.routes = [
                 route
-                for route in router_info.router.routes
+                for route in router.routes
                 if not (isinstance(route, fastapi.routing.APIRoute) and _DELETED_ROUTE_TAG in route.tags)
             ]
-        return {version: router_info.router for version, router_info in router_infos.items()}
+        return routers
+
+    def _validate_all_data_converters_are_applied(self, router: APIRouter, version: Version):
+        path_to_route_methods_mapping, head_response_models, head_request_bodies = self._extract_all_routes_identifiers(
+            router
+        )
+
+        for version_change in version.version_changes:
+            for by_path_converters in [
+                *version_change.alter_response_by_path_instructions.values(),
+                *version_change.alter_request_by_path_instructions.values(),
+            ]:
+                for by_path_converter in by_path_converters:
+                    missing_methods = by_path_converter.methods.difference(
+                        path_to_route_methods_mapping[by_path_converter.path]
+                    )
+
+                    if missing_methods:
+                        raise RouteByPathConverterDoesNotApplyToAnythingError(
+                            f"{by_path_converter.repr_name} "
+                            f'"{version_change.__name__}.{by_path_converter.transformer.__name__}" '
+                            f"failed to find routes with the following methods: {list(missing_methods)}. "
+                            f"This means that you are trying to apply this converter to non-existing endpoint(s). "
+                            "Please, check whether the path and methods are correct. (hint: path must include "
+                            "all path variables and have a name that was used in the version that this "
+                            "VersionChange resides in)"
+                        )
+
+            for by_schema_converters in version_change.alter_request_by_schema_instructions.values():
+                for by_schema_converter in by_schema_converters:
+                    missing_models = set(by_schema_converter.schemas) - head_request_bodies
+                    if missing_models:
+                        raise RouteRequestBySchemaConverterDoesNotApplyToAnythingError(
+                            f"Request by body schema converter "
+                            f'"{version_change.__name__}.{by_schema_converter.transformer.__name__}" '
+                            f"failed to find routes with the following body schemas: "
+                            f"{[m.__name__ for m in missing_models]}. "
+                            f"This means that you are trying to apply this converter to non-existing endpoint(s). "
+                        )
+            for by_schema_converters in version_change.alter_response_by_schema_instructions.values():
+                for by_schema_converter in by_schema_converters:
+                    missing_models = set(by_schema_converter.schemas) - head_response_models
+                    if missing_models:
+                        raise RouteResponseBySchemaConverterDoesNotApplyToAnythingError(
+                            f"Response by response model converter "
+                            f'"{version_change.__name__}.{by_schema_converter.transformer.__name__}" '
+                            f"failed to find routes with the following response models: "
+                            f"{[m.__name__ for m in missing_models]}. "
+                            f"This means that you are trying to apply this converter to non-existing endpoint(s). "
+                        )
+
+    def _extract_all_routes_identifiers(
+        self, router: APIRouter
+    ) -> tuple[defaultdict[str, set[str]], set[Any], set[Any]]:
+        response_models: set[Any] = set()
+        request_bodies: set[Any] = set()
+        path_to_route_methods_mapping: dict[str, set[str]] = defaultdict(set)
+
+        for route in router.routes:
+            if isinstance(route, APIRoute):
+                if route.response_model is not None and lenient_issubclass(route.response_model, BaseModel):
+                    # FIXME: This is going to fail on Pydantic 1
+                    response_models.add(route.response_model)
+                    # Not sure if it can ever be None when it's a simple schema. Eh, I would rather be safe than sorry
+                if _route_has_a_simple_body_schema(route) and route.body_field is not None:
+                    annotation = get_annotation_from_model_field(route.body_field)
+                    if lenient_issubclass(annotation, BaseModel):
+                        # FIXME: This is going to fail on Pydantic 1
+                        request_bodies.add(annotation)
+                path_to_route_methods_mapping[route.path] |= route.methods
+
+        head_response_models = {
+            self.annotation_transformer._change_version_of_annotations(
+                model,
+                self.versions.versioned_directories_with_head[0],
+            )
+            for model in response_models
+        }
+        head_request_bodies = {
+            self.annotation_transformer._change_version_of_annotations(
+                body,
+                self.versions.versioned_directories_with_head[0],
+            )
+            for body in request_bodies
+        }
+
+        return path_to_route_methods_mapping, head_response_models, head_request_bodies
 
     def _replace_internal_representation_with_the_versioned_schema(
         self,
-        copy_of_dependant: Dependant,
+        copy_of_dependant: "Dependant",
         schema_to_internal_request_body_representation: dict[type[BaseModel], type[BaseModel]],
     ):
         body_param: FastAPIModelField = copy_of_dependant.body_params[0]
@@ -378,9 +445,12 @@ def _extract_internal_request_schemas_from_router(
 
     def _extract_internal_request_schemas_from_annotations(annotations: dict[str, Any]):
         for key, annotation in annotations.items():
-            if isinstance(annotation, type(Annotated[int, int])):
+            if isinstance(annotation, type(Annotated[int, int])):  # pyright: ignore[reportArgumentType]
                 args = get_args(annotation)
-                if isinstance(args[1], type) and issubclass(args[1], InternalRepresentationOf):  # pragma: no branch
+                if isinstance(args[1], type) and issubclass(  # pragma: no branch
+                    args[1],
+                    InternalRepresentationOf,  # pyright: ignore[reportDeprecated]
+                ):
                     internal_schema = args[0]
                     original_schema = args[1].mro()[2]
                     schema_to_internal_request_body_representation[original_schema] = internal_schema
@@ -392,9 +462,10 @@ def _extract_internal_request_schemas_from_router(
 
     for route in router.routes:
         if isinstance(route, APIRoute):  # pragma: no branch
-            route.endpoint = _modify_callable(
+            route.endpoint = _modify_callable_annotations(
                 route.endpoint,
                 modify_annotations=_extract_internal_request_schemas_from_annotations,
+                annotation_modifying_wrapper_factory=_copy_endpoint,
             )
             _remake_endpoint_dependencies(route)
     return schema_to_internal_request_body_representation
@@ -424,8 +495,8 @@ class _AnnotationTransformer:
         self.versions = versions
         self.versions.head_schemas_package = head_schemas_package
         self.head_schemas_package = head_schemas_package
-        self.head_version_dir = min(versions.versioned_directories)  # "head" < "v0000_00_00"
-        self.latest_version_dir = max(versions.versioned_directories)  # "v2005_11_11" > "v2000_11_11"
+        self.head_version_dir = min(versions.versioned_directories_with_head)  # "head" < "v0000_00_00"
+        self.latest_version_dir = max(versions.versioned_directories_with_head)  # "v2005_11_11" > "v2000_11_11"
 
         # This cache is not here for speeding things up. It's for preventing the creation of copies of the same object
         # because such copies could produce weird behaviors at runtime, especially if you/fastapi do any comparisons.
@@ -454,7 +525,7 @@ class _AnnotationTransformer:
     ):
         if route.response_model is not None and not ignore_response_model:
             route.response_model = self._change_version_of_annotations(route.response_model, version_dir)
-            route.response_field = fastapi.utils.create_response_field(
+            route.response_field = fastapi.utils.create_model_field(
                 name="Response_" + route.unique_id,
                 type_=route.response_model,
                 mode="serialization",
@@ -501,7 +572,12 @@ class _AnnotationTransformer:
             def modifier(annotation: Any):
                 return self._change_version_of_annotations(annotation, version_dir)
 
-            return _modify_callable(annotation, modifier, modifier)
+            return _modify_callable_annotations(
+                annotation,
+                modifier,
+                modifier,
+                annotation_modifying_wrapper_factory=_copy_function_through_class_based_wrapper,
+            )
         else:
             return annotation
 
@@ -539,7 +615,7 @@ class _AnnotationTransformer:
                     )
                 else:
                     self._validate_source_file_is_located_in_template_dir(annotation, source_file)
-            return get_another_version_of_cls(annotation, version_dir, self.versions.versioned_directories)
+            return get_another_version_of_cls(annotation, version_dir, self.versions.versioned_directories_with_head)
         else:
             return annotation
 
@@ -552,7 +628,7 @@ class _AnnotationTransformer:
         if (
             source_file.startswith(dir_with_versions)
             and not source_file.startswith(template_dir)
-            and any(source_file.startswith(str(d)) for d in self.versions.versioned_directories)
+            and any(source_file.startswith(str(d)) for d in self.versions.versioned_directories_with_head)
         ):
             raise RouterGenerationError(
                 f'"{annotation}" is not defined in "{self.head_version_dir}" even though it must be. '
@@ -562,12 +638,14 @@ class _AnnotationTransformer:
             )
 
 
-def _modify_callable(
-    call: Callable,
+def _modify_callable_annotations(
+    call: _Call,
     modify_annotations: Callable[[dict[str, Any]], dict[str, Any]] = lambda a: a,
     modify_defaults: Callable[[tuple[Any, ...]], tuple[Any, ...]] = lambda a: a,
-):
-    annotation_modifying_wrapper = _copy_function(call)
+    *,
+    annotation_modifying_wrapper_factory: Callable[[_Call], _Call],
+) -> _Call:
+    annotation_modifying_wrapper = annotation_modifying_wrapper_factory(call)
     old_params = inspect.signature(call).parameters
     callable_annotations = annotation_modifying_wrapper.__annotations__
     annotation_modifying_wrapper.__annotations__ = modify_annotations(callable_annotations)
@@ -583,15 +661,12 @@ def _modify_callable(
 
 
 def _remake_endpoint_dependencies(route: fastapi.routing.APIRoute):
-    route.dependant = get_dependant(path=route.path_format, call=route.endpoint)
+    # Unlike get_dependant, APIRoute is the public API of FastAPI and it's (almost) guaranteed to be stable.
+
+    route_copy = fastapi.routing.APIRoute(route.path, route.endpoint, dependencies=route.dependencies)
+    route.dependant = route_copy.dependant
+    route.body_field = route_copy.body_field
     _add_request_and_response_params(route)
-    route.body_field = get_body_field(dependant=route.dependant, name=route.unique_id)
-    for depends in route.dependencies[::-1]:
-        route.dependant.dependencies.insert(
-            0,
-            get_parameterless_sub_dependant(depends=depends, path=route.path_format),
-        )
-    route.app = request_response(route.get_route_handler())
 
 
 def _add_request_and_response_params(route: APIRoute):
@@ -606,7 +681,7 @@ def _add_data_migrations_to_route(
     head_route: Any,
     template_body_field: type[BaseModel] | None,
     template_body_field_name: str | None,
-    dependant_for_request_migrations: Dependant,
+    dependant_for_request_migrations: "Dependant",
     versions: VersionBundle,
 ):
     if not (route.dependant.request_param_name and route.dependant.response_param_name):  # pragma: no cover
@@ -727,46 +802,80 @@ def _get_route_from_func(
     return None
 
 
-def _get_migrated_routes_by_path(version: Version) -> dict[_EndpointPath, set[_EndpointMethod]]:
-    request_by_path_migration_instructions = [
-        version_change.alter_request_by_path_instructions for version_change in version.version_changes
-    ]
-    migrated_routes = defaultdict(set)
-    for instruction_dict in request_by_path_migration_instructions:
-        for path, instruction_list in instruction_dict.items():
-            for instruction in instruction_list:
-                migrated_routes[path] |= instruction.methods
-    return migrated_routes
+def _copy_endpoint(function: Any) -> Any:
+    function = _unwrap_callable(function)
+    function_copy: Any = types.FunctionType(
+        function.__code__,
+        function.__globals__,
+        name=function.__name__,
+        argdefs=function.__defaults__,
+        closure=function.__closure__,
+    )
+    function_copy = functools.update_wrapper(function_copy, function)
+    # Otherwise it will have the same signature as __wrapped__ due to how inspect module works
+    del function_copy.__wrapped__
 
+    function_copy._original_callable = function
+    function.__kwdefaults__ = function.__kwdefaults__.copy() if function.__kwdefaults__ is not None else {}
 
-def _copy_function(function: _T) -> _T:
-    while hasattr(function, "__alt_wrapped__"):
-        function = function.__alt_wrapped__
-    if not isinstance(function, types.FunctionType | types.MethodType):
-        # This means that the callable is actually an instance of a regular class
-        function = function.__call__
-    if inspect.iscoroutinefunction(function):
+    return function_copy
+
+
+class _CallableWrapper:
+    """__eq__ and __hash__ are needed to make sure that dependency overrides work correctly.
+    They are based on putting dependencies (functions) as keys for the dictionary so if we want to be able to
+    override the wrapper, we need to make sure that it is equivalent to the original in __hash__ and __eq__
+    """
+
+    def __init__(self, original_callable: Callable) -> None:
+        super().__init__()
+        self._original_callable = original_callable
+        functools.update_wrapper(self, original_callable)
+
+    @property
+    def __globals__(self):
+        """FastAPI uses __globals__ to resolve forward references in type hints
+        It's supposed to be an attribute on the function but we use it as property to prevent python
+        from trying to pickle globals when we deepcopy this wrapper
+        """
+        #
+        return self._original_callable.__globals__
+
+    def __call__(self, *args: Any, **kwargs: Any):
+        return self._original_callable(*args, **kwargs)
+
+    def __hash__(self):
+        return hash(self._original_callable)
+
+    def __eq__(self, value: object) -> bool:
+        return self._original_callable == value  # pyright: ignore[reportUnnecessaryComparison]
+
+
+class _AsyncCallableWrapper(_CallableWrapper):
+    async def __call__(self, *args: Any, **kwargs: Any):
+        return await self._original_callable(*args, **kwargs)
 
-        @functools.wraps(function)
-        async def annotation_modifying_wrapper(  # pyright: ignore[reportRedeclaration]
-            *args: Any,
-            **kwargs: Any,
-        ) -> Any:
-            return await function(*args, **kwargs)
 
+def _copy_function_through_class_based_wrapper(call: Any):
+    """Separate from copy_endpoint because endpoints MUST be functions in FastAPI, they cannot be cls instances"""
+    call = _unwrap_callable(call)
+
+    if inspect.iscoroutinefunction(call):
+        return _AsyncCallableWrapper(call)
     else:
+        return _CallableWrapper(call)
 
-        @functools.wraps(function)
-        def annotation_modifying_wrapper(
-            *args: Any,
-            **kwargs: Any,
-        ) -> Any:
-            return function(*args, **kwargs)
 
-    # Otherwise it will have the same signature as __wrapped__ due to how inspect module works
-    annotation_modifying_wrapper.__alt_wrapped__ = (  # pyright: ignore[reportAttributeAccessIssue]
-        annotation_modifying_wrapper.__wrapped__
-    )
-    del annotation_modifying_wrapper.__wrapped__
+def _unwrap_callable(call: Any) -> Any:
+    while hasattr(call, "_original_callable"):
+        call = call._original_callable
+    if not isinstance(call, types.FunctionType | types.MethodType):
+        # This means that the callable is actually an instance of a regular class
+        call = call.__call__
+
+    return call
+
 
-    return cast(_T, annotation_modifying_wrapper)
+def _route_has_a_simple_body_schema(route: APIRoute) -> bool:
+    # Remember this: if len(body_params) == 1, then route.body_schema == route.dependant.body_params[0]
+    return len(route.dependant.body_params) == 1

cadwyn/routing.py

@@ -1,5 +1,4 @@
 import bisect
-from collections import OrderedDict
 from collections.abc import Sequence
 from contextvars import ContextVar
 from datetime import date
@@ -13,7 +12,12 @@ from starlette.responses import RedirectResponse
 from starlette.routing import BaseRoute, Match
 from starlette.types import Receive, Scope, Send
 
-from .route_generation import InternalRepresentationOf, generate_versioned_routers
+from cadwyn._utils import same_definition_as_in
+
+from .route_generation import (
+    InternalRepresentationOf,  # pyright: ignore[reportDeprecated]
+    generate_versioned_routers,
+)
 
 # TODO: Remove this in a major version. This is only here for backwards compatibility
 __all__ = ["InternalRepresentationOf", "generate_versioned_routers"]
@@ -44,48 +48,47 @@ class _RootHeaderAPIRouter(APIRouter):
         **kwargs: Any,
     ):
         super().__init__(*args, **kwargs)
-        self.versioned_routes: dict[date, list[BaseRoute]] = {}
-        self.unversioned_routes: list[BaseRoute] = []
+        self.versioned_routers: dict[date, APIRouter] = {}
         self.api_version_header_name = api_version_header_name.lower()
         self.api_version_var = api_version_var
+        self.unversioned_routes: list[BaseRoute] = []
 
     @cached_property
-    def sorted_versioned_routes(self):
-        sorted_routes = sorted(self.versioned_routes.items())
-        return OrderedDict(sorted_routes)
+    def sorted_versions(self):
+        return sorted(self.versioned_routers.keys())
 
     @cached_property
     def min_routes_version(self):
-        return min(self.sorted_versioned_routes.keys())
+        return min(self.sorted_versions)
 
-    def find_closest_date_but_not_new(self, request_version: date):
-        routes = list(self.sorted_versioned_routes.keys())
-        index = bisect.bisect_left(routes, request_version)
+    def find_closest_date_but_not_new(self, request_version: date) -> date:
+        index = bisect.bisect_left(self.sorted_versions, request_version)
         # as bisect_left returns the index where to insert item x in list a, assuming a is sorted
         # we need to get the previous item and that will be a match
-        return routes[index - 1]
+        return self.sorted_versions[index - 1]
 
-    def pick_version(
-        self,
-        request_header_value: date,
-    ) -> list[BaseRoute]:
-        routes = []
+    def pick_version(self, request_header_value: date) -> list[BaseRoute]:
         request_version = request_header_value.isoformat()
 
         if self.min_routes_version > request_header_value:
             # then the request version is older that the oldest route we have
             _logger.info(
-                f"Request version {request_version} "
-                f"is older than the oldest "
-                f"version {self.min_routes_version.isoformat()} ",
+                "Request version is older than the oldest version. No route can match this version",
+                extra={
+                    "oldest_version": self.min_routes_version.isoformat(),
+                    "request_version": request_version,
+                },
             )
-            return routes
+            return []
         version_chosen = self.find_closest_date_but_not_new(request_header_value)
         _logger.info(
-            f"Partial match. The endpoint with {version_chosen} "
-            f"version was selected for API call version {request_version}",
+            "Partial match. The endpoint with a lower version was selected for the API call",
+            extra={
+                "version_chosen": version_chosen,
+                "request_version": request_version,
+            },
         )
-        return self.versioned_routes[version_chosen]
+        return self.versioned_routers[version_chosen].routes
 
     async def __call__(self, scope: Scope, receive: Receive, send: Send) -> None:
         """
@@ -104,12 +107,32 @@ class _RootHeaderAPIRouter(APIRouter):
         # if there will be a value, we search for the most suitable version
         if not header_value:
             routes = self.unversioned_routes
-        elif header_value in self.versioned_routes:
-            routes = self.versioned_routes[header_value]
+        elif header_value in self.versioned_routers:
+            routes = self.versioned_routers[header_value].routes
         else:
             routes = self.pick_version(request_header_value=header_value)
         await self.process_request(scope=scope, receive=receive, send=send, routes=routes)
 
+    @same_definition_as_in(APIRouter.add_api_route)
+    def add_api_route(self, *args: Any, **kwargs: Any):
+        super().add_api_route(*args, **kwargs)
+        self.unversioned_routes.append(self.routes[-1])
+
+    @same_definition_as_in(APIRouter.add_route)
+    def add_route(self, *args: Any, **kwargs: Any):
+        super().add_route(*args, **kwargs)
+        self.unversioned_routes.append(self.routes[-1])
+
+    @same_definition_as_in(APIRouter.add_api_websocket_route)
+    def add_api_websocket_route(self, *args: Any, **kwargs: Any):  # pragma: no cover
+        super().add_api_websocket_route(*args, **kwargs)
+        self.unversioned_routes.append(self.routes[-1])
+
+    @same_definition_as_in(APIRouter.add_websocket_route)
+    def add_websocket_route(self, *args: Any, **kwargs: Any):  # pragma: no cover
+        super().add_websocket_route(*args, **kwargs)
+        self.unversioned_routes.append(self.routes[-1])
+
     async def process_request(self, scope: Scope, receive: Receive, send: Send, routes: Sequence[BaseRoute]) -> None:
         """
         its a copy-paste from starlette.routing.Router