fastapi-deferred-init 0.3.2__tar.gz → 0.3.4__tar.gz

{fastapi_deferred_init-0.3.2 → fastapi_deferred_init-0.3.4}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: fastapi-deferred-init
-Version: 0.3.2
+Version: 0.3.4
 Summary: Faster FastAPI start-up time for Projects with many nested routers
 Keywords: fastapi,speed,router,startup,optimization
 Author-Email: Jan Vollmer <jan@vllmr.dev>
@@ -9,16 +9,16 @@ Classifier: Environment :: Plugins
 Classifier: Framework :: FastAPI
 Classifier: Intended Audience :: Developers
 Classifier: License :: OSI Approved :: MIT License
-Classifier: Programming Language :: Python :: 3.10
 Classifier: Programming Language :: Python :: 3.11
 Classifier: Programming Language :: Python :: 3.12
 Classifier: Programming Language :: Python :: 3.13
 Classifier: Programming Language :: Python :: 3.14
+Classifier: Programming Language :: Python :: 3.15
 Classifier: Typing :: Typed
 Project-URL: Source, https://github.com/jvllmr/fastapi-deferred-init
 Project-URL: Changelog, https://github.com/jvllmr/fastapi-deferred-init/releases
-Requires-Python: >=3.10
-Requires-Dist: fastapi>=0.140.7
+Requires-Python: >=3.11
+Requires-Dist: fastapi>=0.162.0
 Description-Content-Type: text/markdown
 
 # fastapi-deferred-init

{fastapi_deferred_init-0.3.2 → fastapi_deferred_init-0.3.4}/pyproject.toml

@@ -12,24 +12,24 @@ authors = [
     { name = "Jan Vollmer", email = "jan@vllmr.dev" },
 ]
 dependencies = [
-    "fastapi>=0.140.7",
+    "fastapi>=0.162.0",
 ]
-requires-python = ">=3.10"
+requires-python = ">=3.11"
 readme = "README.md"
 classifiers = [
     "Environment :: Plugins",
     "Framework :: FastAPI",
     "Intended Audience :: Developers",
     "License :: OSI Approved :: MIT License",
-    "Programming Language :: Python :: 3.10",
     "Programming Language :: Python :: 3.11",
     "Programming Language :: Python :: 3.12",
     "Programming Language :: Python :: 3.13",
     "Programming Language :: Python :: 3.14",
+    "Programming Language :: Python :: 3.15",
     "Typing :: Typed",
 ]
 dynamic = []
-version = "0.3.2"
+version = "0.3.4"
 
 [project.license]
 text = "MIT"
@@ -45,9 +45,6 @@ requires = [
 build-backend = "pdm.backend"
 
 [tool.pdm]
-ignore_package_warnings = [
-    "pre-commit",
-]
 plugins = [
     "sync-pre-commit-lock",
 ]
@@ -69,7 +66,7 @@ FULL_TEST = "true"
 
 [tool.pdm.scripts.post_install]
 composite = [
-    "pre-commit install",
+    "prek install",
     "pdm install --plugins --frozen-lock",
     "pip install ./fastapi",
 ]
@@ -80,18 +77,33 @@ source = "scm"
 [tool.isort]
 profile = "black"
 
-[tool.pycln]
-all = true
+[tool.ruff]
+target-version = "py311"
+
+[tool.ruff.lint]
+extend-select = [
+    "F",
+]
+
+[tool.ty.environment]
+python-version = "3.11"
+python = ".venv"
+
+[tool.ty.src]
+include = [
+    "src",
+    "tests",
+]
 
 [dependency-groups]
 dev = [
-    "pytest>=9.1.1",
-    "ruff>=0.15.20",
-    "pre-commit>=4.3.0",
-    "mypy>=2.1.0",
+    "pytest>=9.1.1,<9.2",
+    "ruff>=0.17.1",
     "tuna>=0.5.15",
-    "pytest-benchmark>=5.2.3",
-    "pip>=26.1.2",
-    "inline-snapshot>=0.34.2",
-    "httpx2>=2.9.1",
+    "pytest-benchmark>=5.3.0",
+    "pip>=26.2.1",
+    "inline-snapshot>=0.36.1",
+    "httpx2>=2.14.0",
+    "prek>=0.5.9",
+    "ty>=0.0.95",
 ]

{fastapi_deferred_init-0.3.2 → fastapi_deferred_init-0.3.4}/src/fastapi_deferred_init/patch.py

@@ -1,4 +1,9 @@
-from .routing import _populate_api_route_state, DeferringAPIRoute, DeferringAPIRouter
+from .routing import (
+    DeferringAPIRoute,
+    DeferringAPIRouter,
+    _populate_api_route_state,
+    apply_include_patch,
+)
 
 
 def apply_patch() -> None:
@@ -8,6 +13,7 @@ def apply_patch() -> None:
     routing._populate_api_route_state = _populate_api_route_state  # ty:ignore[invalid-assignment]
     routing.APIRoute = DeferringAPIRoute  # ty:ignore[invalid-assignment]
     routing.APIRouter = DeferringAPIRouter  # ty:ignore[invalid-assignment]
+    apply_include_patch(routing)
 
     import fastapi
 

{fastapi_deferred_init-0.3.2 → fastapi_deferred_init-0.3.4}/src/fastapi_deferred_init/routing.py

@@ -1,36 +1,37 @@
-from fastapi.dependencies.models import Dependant
 import inspect
+from collections.abc import Callable, Sequence
 from enum import Enum, IntEnum
 from functools import cached_property
-from typing import Any, Callable, Union, cast
-from collections.abc import Sequence
-
+from typing import Any, cast
 
-from fastapi.sse import (
-    EventSourceResponse,
-    ServerSentEvent,
-)
-from fastapi.routing import _is_async_gen_callable, _is_gen_callable
-from fastapi import params, routing  # type: ignore[attr-defined]
 from fastapi._compat import ModelField, lenient_issubclass
 from fastapi.datastructures import Default, DefaultPlaceholder
+from fastapi.dependencies.models import Dependant
 from fastapi.dependencies.utils import (
-    _should_embed_body_fields,
     _get_body_field,
+    _get_flat_body_params,
+    _should_embed_body_fields,
     get_dependant,
     get_parameterless_sub_dependant,
-    get_typed_return_annotation,
     get_stream_item_type,
-    _get_flat_body_params,
+    get_typed_return_annotation,
 )
 from fastapi.responses import JSONResponse, Response
+from fastapi.routing import _is_async_gen_callable, _is_gen_callable
+from fastapi.sse import (
+    EventSourceResponse,
+    ServerSentEvent,
+)
 from fastapi.types import IncEx
 from fastapi.utils import (
     create_model_field,
     generate_unique_id,
+    get_value_or_default,
     is_body_allowed_for_status_code,
 )
 
+from fastapi import params, routing  # type: ignore[attr-defined]
+
 
 def _add_cache_attribute(
     instance: routing._APIRouteLike, name: str, func: Callable[[Any], Any]
@@ -54,7 +55,7 @@ def _populate_api_route_state(
     path: str,
     endpoint: Callable[..., Any],
     *,
-    response_model: Any = Default(None),
+    response_model: Any = Default(None),  # noqa: B008
     status_code: int | None = None,
     tags: list[str | Enum] | None = None,
     dependencies: Sequence[params.Depends] | None = None,
@@ -73,40 +74,20 @@ def _populate_api_route_state(
     response_model_exclude_defaults: bool = False,
     response_model_exclude_none: bool = False,
     include_in_schema: bool = True,
-    response_class: type[Response] | DefaultPlaceholder = Default(JSONResponse),
+    response_class: type[Response] | DefaultPlaceholder = Default(JSONResponse),  # noqa: B008
     dependency_overrides_provider: Any | None = None,
     callbacks: list[routing.BaseRoute] | None = None,
     openapi_extra: dict[str, Any] | None = None,
-    generate_unique_id_function: Callable[[Any], str] | DefaultPlaceholder = Default(
+    generate_unique_id_function: Callable[[Any], str] | DefaultPlaceholder = Default(  # noqa: B008
         generate_unique_id
     ),
-    strict_content_type: bool | DefaultPlaceholder = Default(True),
+    strict_content_type: bool | DefaultPlaceholder = Default(True),  # noqa: B008
+    stream_item_type: Any | None = None,
 ) -> None:
     route.path = path
     route.endpoint = endpoint
-    route.stream_item_type = None
-    if isinstance(response_model, DefaultPlaceholder):
-        return_annotation = get_typed_return_annotation(endpoint)
-        if lenient_issubclass(return_annotation, Response):
-            response_model = None
-        else:
-            stream_item = get_stream_item_type(return_annotation)
-            if stream_item is not None:
-                # Extract item type for JSONL or SSE streaming when
-                # response_class is DefaultPlaceholder (JSONL) or
-                # EventSourceResponse (SSE).
-                # ServerSentEvent is excluded: it's a transport
-                # wrapper, not a data model, so it shouldn't feed
-                # into validation or OpenAPI schema generation.
-                if (
-                    isinstance(response_class, DefaultPlaceholder)
-                    or lenient_issubclass(response_class, EventSourceResponse)
-                ) and not lenient_issubclass(stream_item, ServerSentEvent):
-                    route.stream_item_type = stream_item
-                response_model = None
-            else:
-                response_model = return_annotation
-    route.response_model = response_model
+    route.stream_item_type = stream_item_type
+
     route.summary = summary
     route.response_description = response_description
     route.deprecated = deprecated
@@ -144,13 +125,18 @@ def _populate_api_route_state(
     if isinstance(status_code, IntEnum):
         status_code = int(status_code)
     route.status_code = status_code
-    if route.response_model:
-        assert is_body_allowed_for_status_code(status_code), (
-            f"Status code {status_code} must not have a response body"
-        )
+
+    # Store the raw response_model / stream_item_type parameters so the
+    # deferred cached_properties can access them per-instance (not via
+    # closure, which would be shared across all instances of the class).
+    route._raw_response_model = response_model  # ty: ignore[unresolved-attribute]
+    route._raw_stream_item_type = stream_item_type  # ty: ignore[unresolved-attribute]
 
     def _response_field(self):
         if self.response_model:
+            assert is_body_allowed_for_status_code(self.status_code), (
+                f"Status code {self.status_code} must not have a response body"
+            )
             response_name = "Response_" + self.unique_id
             return create_model_field(
                 name=response_name,
@@ -180,8 +166,8 @@ def _populate_api_route_state(
     # truncate description text to the content preceding the first "form feed"
     route.description = route.description.split("\f")[0].strip()
 
-    def _response_fields(self) -> dict[Union[int, str], ModelField]:
-        response_fields: dict[Union[int, str], ModelField] = {}
+    def _response_fields(self) -> dict[int | str, ModelField]:
+        response_fields: dict[int | str, ModelField] = {}
         for additional_status_code, response in self.responses.items():
             assert isinstance(response, dict), "An additional response must be a dict"
             model = response.get("model")
@@ -254,6 +240,50 @@ def _populate_api_route_state(
 
     _add_cache_attribute(route, "is_json_stream", _is_json_stream)
 
+    def _resolved_response_model_stream_item(self):
+        resolved_model = self._raw_response_model
+        resolved_item_type = self._raw_stream_item_type
+        if isinstance(resolved_model, DefaultPlaceholder):
+            return_annotation = get_typed_return_annotation(self.endpoint)
+            if lenient_issubclass(return_annotation, Response):
+                resolved_model = None
+            else:
+                stream_item = get_stream_item_type(return_annotation)
+                if stream_item is not None and self.is_generator:
+                    # Extract item type for JSONL or SSE streaming for
+                    # generator endpoints when response_class is
+                    # DefaultPlaceholder (JSONL) or EventSourceResponse (SSE).
+                    # ServerSentEvent is excluded: it's a transport
+                    # wrapper, not a data model, so it shouldn't feed
+                    # into validation or OpenAPI schema generation.
+                    if (
+                        isinstance(self.response_class, DefaultPlaceholder)
+                        or lenient_issubclass(self.response_class, EventSourceResponse)
+                    ) and not lenient_issubclass(stream_item, ServerSentEvent):
+                        resolved_item_type = stream_item
+                    resolved_model = None
+                else:
+                    resolved_model = return_annotation
+
+        return resolved_model, resolved_item_type
+
+    _add_cache_attribute(
+        route,
+        "_resolved_response_model_stream_item",
+        _resolved_response_model_stream_item,
+    )
+
+    def _response_model(self):
+
+        return self._resolved_response_model_stream_item[0]
+
+    _add_cache_attribute(route, "response_model", _response_model)
+
+    def _stream_item_type(self):
+        return self._resolved_response_model_stream_item[1]
+
+    _add_cache_attribute(route, "stream_item_type", _stream_item_type)
+
 
 class DeferringAPIRoute(routing.APIRoute):
     def __init__(
@@ -273,3 +303,93 @@ class DeferringAPIRouter(routing.APIRouter):
         if "route_class" not in kwargs:
             kwargs["route_class"] = DeferringAPIRoute
         super().__init__(*args, **kwargs)
+
+
+def _from_api_route_deferred(
+    cls: type, *, original_route: Any, include_context: Any
+) -> Any:
+    """Deferring replacement for fastapi>=0.162's `_EffectiveRouteContext.from_api_route`.
+
+    Upstream eagerly builds the ASGI app for every route of an included router
+    (`context.app = request_response(original_route.get_route_handler())`),
+    which forces the deferred dependant/body_field/response_model to be
+    computed at include time. Defer `app` to first access instead, like
+    DeferringAPIRoute does for direct routes.
+    """
+    route = cast(routing._APIRouteLike, original_route)
+    context = cls(original_route=original_route)
+    _populate_api_route_state(
+        cast(routing._APIRouteLike, context),
+        include_context.path_for(original_route),
+        route.endpoint,
+        response_model=route.response_model,
+        status_code=route.status_code,
+        tags=[*include_context.tags, *route.tags],
+        dependencies=[*include_context.dependencies, *route.dependencies],
+        summary=route.summary,
+        description=route.description,
+        response_description=route.response_description,
+        responses={**include_context.responses, **route.responses},
+        deprecated=route.deprecated or include_context.deprecated,
+        methods=route.methods,
+        operation_id=route.operation_id,
+        response_model_include=route.response_model_include,
+        response_model_exclude=route.response_model_exclude,
+        response_model_by_alias=route.response_model_by_alias,
+        response_model_exclude_unset=route.response_model_exclude_unset,
+        response_model_exclude_defaults=route.response_model_exclude_defaults,
+        response_model_exclude_none=route.response_model_exclude_none,
+        include_in_schema=route.include_in_schema and include_context.include_in_schema,
+        response_class=get_value_or_default(
+            route.response_class,
+            include_context.included_router.default_response_class,
+            include_context.default_response_class,
+        ),
+        name=route.name,
+        dependency_overrides_provider=include_context.dependency_overrides_provider,
+        callbacks=[*include_context.callbacks, *(route.callbacks or [])],
+        openapi_extra=route.openapi_extra,
+        generate_unique_id_function=get_value_or_default(
+            route.generate_unique_id_function,
+            include_context.included_router.generate_unique_id_function,
+            include_context.generate_unique_id_function,
+        ),
+        strict_content_type=get_value_or_default(
+            route.strict_content_type,
+            include_context.included_router.strict_content_type,
+            include_context.strict_content_type,
+        ),
+        stream_item_type=route.stream_item_type,
+    )
+
+    def _app(self: Any) -> Any:
+        # Build the handler lazily with the effective context active, mirroring
+        # upstream's ContextVar usage so integrations wrapping dependant.call
+        # while constructing the handler still see the context.
+        context_var = getattr(routing, "_effective_route_context_var", None)
+        if context_var is not None:
+            token = context_var.set(self)
+            try:
+                handler = self.original_route.get_route_handler()
+            finally:
+                context_var.reset(token)
+        else:
+            handler = self.original_route.get_route_handler()
+        return routing.request_response(handler)
+
+    _add_cache_attribute(context, "app", _app)
+    return context
+
+
+def apply_include_patch(routing_module: Any) -> bool:
+    """Patch fastapi>=0.162's include machinery to defer app construction.
+
+    Returns True when the patch was applied, i.e. the running fastapi version
+    has `_EffectiveRouteContext` (older versions re-run APIRoute.__init__ on
+    include, which the route-class patch already covers).
+    """
+    effective_route_context = getattr(routing_module, "_EffectiveRouteContext", None)
+    if effective_route_context is None:
+        return False
+    effective_route_context.from_api_route = classmethod(_from_api_route_deferred)
+    return True

{fastapi_deferred_init-0.3.2 → fastapi_deferred_init-0.3.4}/tests/data/template.py

@@ -1,8 +1,8 @@
 from fastapi import APIRouter, Depends
 
-dependency0 = lambda: 1  # noqa: E731
+dependency0 = lambda: 1
 
-dependency = lambda: 0  # noqa: E731
+dependency = lambda: 0
 
 
 def dependency1(sub_dependant: int = Depends(dependency0)):
@@ -13,7 +13,7 @@ router1 = APIRouter(prefix="/prefix1")
 
 
 @router1.get("/get1")
-def get1(dependency=Depends(dependency)):
+def get1(dependency=Depends(dependency)):  # noqa: B008
     return {"1": 1}
 
 
@@ -21,7 +21,7 @@ router2 = APIRouter(prefix="/prefix2")
 
 
 @router2.get("/get2")
-def get2(dependency=Depends(dependency)):
+def get2(dependency=Depends(dependency)):  # noqa: B008
     return {"2": 2}
 
 

{fastapi_deferred_init-0.3.2 → fastapi_deferred_init-0.3.4}/tests/helpers.py

@@ -1,10 +1,22 @@
 from __future__ import annotations
 
 import importlib
+import importlib.util
 import sys
 from contextlib import contextmanager
 from cProfile import Profile
 from pstats import SortKey, Stats
+from typing import TYPE_CHECKING
+
+from fastapi_deferred_init.routing import (
+    DeferringAPIRoute,
+    DeferringAPIRouter,
+    _from_api_route_deferred,
+    _populate_api_route_state,
+)
+
+if TYPE_CHECKING:
+    import pytest
 
 
 @contextmanager
@@ -26,6 +38,21 @@ def load_code():
 def import_via_file_path(module_name: str, file_path: str):
     # https://docs.python.org/3/library/importlib.html#importing-a-source-file-directly
     spec = importlib.util.spec_from_file_location(module_name, file_path)
+    assert spec is not None and spec.loader is not None
     module = importlib.util.module_from_spec(spec)
     sys.modules[module_name] = module
     spec.loader.exec_module(module)
+
+
+def apply_monkeypatch(monkeypatch: pytest.MonkeyPatch) -> None:
+    monkeypatch.setattr(
+        "fastapi.routing._populate_api_route_state", _populate_api_route_state
+    )
+    monkeypatch.setattr("fastapi.routing.APIRoute", DeferringAPIRoute)
+    monkeypatch.setattr("fastapi.routing.APIRouter", DeferringAPIRouter)
+    monkeypatch.setattr("fastapi.APIRouter", DeferringAPIRouter)
+    monkeypatch.setattr(
+        "fastapi.routing._EffectiveRouteContext.from_api_route",
+        classmethod(_from_api_route_deferred),
+        raising=False,
+    )

{fastapi_deferred_init-0.3.2 → fastapi_deferred_init-0.3.4}/tests/test_lib.py

@@ -1,19 +1,17 @@
 import os
 
 import pytest
+from fastapi.testclient import TestClient
 from pydantic import BaseModel
 
-from fastapi import FastAPI, APIRouter
-from fastapi import routing
-from fastapi.testclient import TestClient
+from fastapi import APIRouter, FastAPI, routing
 from fastapi_deferred_init.routing import (
-    _populate_api_route_state,
     DeferringAPIRoute,
     DeferringAPIRouter,
 )
 
 from .data.gen_code_ast import create_code
-from .helpers import import_via_file_path, load_code
+from .helpers import apply_monkeypatch, import_via_file_path, load_code
 
 
 def skip_test(use_lib: bool):
@@ -21,15 +19,6 @@ def skip_test(use_lib: bool):
         pytest.skip()
 
 
-def apply_monkeypatch(monkeypatch):
-    monkeypatch.setattr(
-        "fastapi.routing._populate_api_route_state", _populate_api_route_state
-    )
-    monkeypatch.setattr("fastapi.routing.APIRoute", DeferringAPIRoute)
-    monkeypatch.setattr("fastapi.routing.APIRouter", DeferringAPIRouter)
-    monkeypatch.setattr("fastapi.APIRouter", DeferringAPIRouter)
-
-
 @pytest.mark.parametrize(["use_lib"], [(True,), (False,)])
 def test_basic(use_lib: bool, benchmark, monkeypatch):
     skip_test(use_lib=use_lib)
@@ -107,10 +96,10 @@ def test_fastapi_openapi_schema(monkeypatch):
         "fastapi/tests/test_openapi_examples.py",
     )
 
-    from fastapi_clone.tests.test_additional_properties import (  # noqa # type: ignore
+    from fastapi_clone.tests.test_additional_properties import (  # type: ignore
         test_openapi_schema as fastapi_test_openapi_schema_additional,
     )
-    from fastapi_clone.tests.test_openapi_examples import (  # noqa # type: ignore
+    from fastapi_clone.tests.test_openapi_examples import (  # type: ignore
         test_openapi_schema as fastapi_test_openapi_schema,
     )
 
@@ -125,9 +114,11 @@ def test_fastapi_sse(monkeypatch):
         "fastapi/tests/test_sse.py",
     )
 
+    from fastapi_clone.tests.test_sse import (  # ty: ignore[unresolved-import]
+        client_fixture as fastapi_client_fixture,
+    )
     from fastapi_clone.tests.test_sse import (  # type: ignore
         test_raw_data_sent_without_json_encoding as fastapi_test_raw_data_sent_without_json_encoding,
-        client_fixture as fastapi_client_fixture,
     )
 
     for client in fastapi_client_fixture.__wrapped__():

fastapi_deferred_init-0.3.4/tests/test_realworld.py

@@ -0,0 +1,314 @@
+"""Real-world usage tests for fastapi-deferred-init.
+
+These tests mimic common patterns found in production FastAPI apps
+that go beyond what the existing tests cover.
+"""
+
+import typing as t
+
+from fastapi.responses import JSONResponse, PlainTextResponse
+from fastapi.testclient import TestClient
+from pydantic import BaseModel
+
+from fastapi import Depends, FastAPI, Header, HTTPException, Query, routing, status
+
+from .helpers import apply_monkeypatch
+
+
+class User(BaseModel):
+    id: int
+    name: str
+    email: str
+
+
+class Item(BaseModel):
+    id: int
+    title: str
+    owner_id: int
+
+
+def _make_app():
+    """Build a realistic app. Route creation order matters: router routes
+    are created before app-level routes because decorators run top-to-bottom."""
+
+    def get_current_user() -> str:
+        return "fake-token"
+
+    def get_db() -> str:
+        return "fake-db-conn"
+
+    # --- sub-router: items (created FIRST, so its closures get installed on the class) ---
+    items_router = routing.APIRouter(prefix="/items", tags=["items"])
+
+    @items_router.get("/{item_id}", response_model=Item)
+    def read_item(item_id: int, db: t.Annotated[str, Depends(get_db)]):
+        return Item(id=item_id, title=f"Item {item_id}", owner_id=1)
+
+    @items_router.post("", response_model=Item, status_code=status.HTTP_201_CREATED)
+    def create_item(item: Item, user: t.Annotated[str, Depends(get_current_user)]):
+        return item
+
+    # --- sub-router: users ---
+    users_router = routing.APIRouter(prefix="/users", tags=["users"])
+
+    @users_router.get("/{user_id}", response_model=User)
+    def read_user(user_id: int):
+        if user_id == 999:
+            raise HTTPException(status_code=404, detail="User not found")
+        return User(
+            id=user_id, name=f"User {user_id}", email=f"user{user_id}@example.com"
+        )
+
+    # --- v1 router ---
+    v1_router = routing.APIRouter(prefix="/v1")
+    v1_router.include_router(items_router)
+    v1_router.include_router(users_router, prefix="/u", tags=["v1-users"])
+
+    # --- app (created LAST) ---
+    app = FastAPI(title="Real World App")
+
+    @app.get("/", response_class=PlainTextResponse)
+    def root():
+        return "Hello World"
+
+    @app.get("/health")
+    def health():
+        return {"status": "ok"}
+
+    app.include_router(v1_router)
+    return app
+
+
+def test_nested_routers_with_response_model_and_dependencies(monkeypatch):
+    apply_monkeypatch(monkeypatch)
+    app = _make_app()
+    client = TestClient(app)
+
+    # Direct app routes
+    resp = client.get("/")
+    assert resp.status_code == 200, resp.text
+    assert resp.text == "Hello World"
+
+    resp = client.get("/health")
+    assert resp.status_code == 200
+    assert resp.json() == {"status": "ok"}
+
+    # Nested router routes
+    resp = client.get("/v1/items/42")
+    assert resp.status_code == 200, resp.text
+    assert resp.json() == {"id": 42, "title": "Item 42", "owner_id": 1}
+
+    resp = client.post("/v1/items", json={"id": 1, "title": "Test", "owner_id": 2})
+    assert resp.status_code == 201, resp.text
+    assert resp.json() == {"id": 1, "title": "Test", "owner_id": 2}
+
+    resp = client.get("/v1/u/users/5")
+    assert resp.status_code == 200, resp.text
+    assert resp.json() == {"id": 5, "name": "User 5", "email": "user5@example.com"}
+
+    resp = client.get("/v1/u/users/999")
+    assert resp.status_code == 404, resp.text
+
+    # OpenAPI schema should be generatable
+    resp = client.get("/openapi.json")
+    assert resp.status_code == 200, resp.text
+    schema = resp.json()
+    assert "/v1/items/{item_id}" in schema["paths"]
+    assert "/v1/u/users/{user_id}" in schema["paths"]
+    assert "/" in schema["paths"]
+
+
+def test_response_model_not_leaked_between_routes(monkeypatch):
+    """Regression test: response_model from one route must not leak to another.
+
+    The deferred cached_property closures were installed once per class,
+    capturing the first route's parameters for all subsequent routes.
+    """
+    apply_monkeypatch(monkeypatch)
+
+    # First route with response_model — its closures get installed on the class
+    router_a = routing.APIRouter()
+
+    @router_a.get("/a", response_model=Item)
+    def get_a():
+        return Item(id=1, title="A", owner_id=0)
+
+    # Second route WITHOUT response_model — should NOT inherit Item
+    router_b = routing.APIRouter()
+
+    @router_b.get("/b")
+    def get_b():
+        return {"plain": "dict"}
+
+    app = FastAPI()
+    app.include_router(router_a)
+    app.include_router(router_b)
+
+    # Check the original routes' response_model
+    for r in router_b.routes:
+        assert r.response_model is None, (  # ty: ignore[unresolved-attribute]
+            f"Route {r.path} incorrectly has response_model={r.response_model} "  # ty: ignore[unresolved-attribute]
+            f"(leaked from another route)"
+        )
+
+    client = TestClient(app)
+    resp = client.get("/b")
+    assert resp.status_code == 200, resp.text
+    assert resp.json() == {"plain": "dict"}
+
+    # Also verify /a still works
+    resp = client.get("/a")
+    assert resp.status_code == 200, resp.text
+    assert resp.json() == {"id": 1, "title": "A", "owner_id": 0}
+
+
+def test_custom_response_class_not_leaked(monkeypatch):
+    """Custom response_class on one route must not leak to others."""
+    apply_monkeypatch(monkeypatch)
+
+    router = routing.APIRouter()
+
+    @router.get("/html", response_class=PlainTextResponse)
+    def html():
+        return "<h1>hi</h1>"
+
+    @router.get("/json")
+    def json_route():
+        return {"ok": True}
+
+    app = FastAPI()
+    app.include_router(router)
+
+    client = TestClient(app)
+    resp = client.get("/html")
+    assert resp.status_code == 200
+    assert "text/plain" in resp.headers["content-type"]
+
+    resp = client.get("/json")
+    assert resp.status_code == 200
+    assert "application/json" in resp.headers["content-type"]
+    assert resp.json() == {"ok": True}
+
+
+def test_dependency_overrides(monkeypatch):
+    apply_monkeypatch(monkeypatch)
+
+    def original_dep():
+        return "original"
+
+    def override_dep():
+        return "overridden"
+
+    router = routing.APIRouter()
+
+    @router.get("/dep")
+    def get_dep(val: t.Annotated[str, Depends(original_dep)]):
+        return {"val": val}
+
+    app = FastAPI()
+    app.include_router(router)
+    app.dependency_overrides[original_dep] = override_dep
+
+    client = TestClient(app)
+    resp = client.get("/dep")
+    assert resp.status_code == 200, resp.text
+    assert resp.json() == {"val": "overridden"}
+
+
+def test_multiple_includes_same_router(monkeypatch):
+    apply_monkeypatch(monkeypatch)
+
+    router = routing.APIRouter()
+
+    @router.get("/ping")
+    def ping():
+        return {"pong": True}
+
+    app = FastAPI()
+    app.include_router(router, prefix="/api/v1")
+    app.include_router(router, prefix="/api/v2")
+
+    client = TestClient(app)
+    for prefix in ("/api/v1", "/api/v2"):
+        resp = client.get(f"{prefix}/ping")
+        assert resp.status_code == 200, f"{prefix}: {resp.text}"
+        assert resp.json() == {"pong": True}
+
+
+def test_path_and_query_params(monkeypatch):
+    apply_monkeypatch(monkeypatch)
+
+    router = routing.APIRouter(prefix="/search")
+
+    @router.get("/{category}")
+    def search(
+        category: str,
+        q: str = Query(default=""),
+        limit: int = Query(default=10, le=100),
+        x_token: str = Header(default=""),
+    ):
+        return {"category": category, "q": q, "limit": limit, "token": x_token}
+
+    app = FastAPI()
+    app.include_router(router)
+
+    client = TestClient(app)
+    resp = client.get("/search/books?q=fastapi&limit=5", headers={"X-Token": "abc"})
+    assert resp.status_code == 200, resp.text
+    assert resp.json() == {
+        "category": "books",
+        "q": "fastapi",
+        "limit": 5,
+        "token": "abc",
+    }
+
+
+def test_head_returns_405_like_upstream(monkeypatch):
+    """HEAD on a GET-only route returns 405 — same as unpatched FastAPI."""
+    apply_monkeypatch(monkeypatch)
+
+    router = routing.APIRouter()
+
+    @router.get("/auto")
+    def auto():
+        return {"ok": True}
+
+    app = FastAPI()
+    app.include_router(router)
+
+    client = TestClient(app)
+    resp = client.head("/auto")
+    assert resp.status_code == 405, resp.text
+
+
+def test_exception_handlers(monkeypatch):
+    apply_monkeypatch(monkeypatch)
+
+    router = routing.APIRouter()
+
+    class CustomError(Exception):
+        pass
+
+    @router.get("/custom-error")
+    def raise_custom():
+        raise CustomError("something went wrong")
+
+    @router.get("/validation-error")
+    def cause_validation(q: int):
+        return {"q": q}
+
+    app = FastAPI()
+
+    @app.exception_handler(CustomError)
+    def custom_handler(request, exc):
+        return JSONResponse(status_code=418, content={"error": str(exc)})
+
+    app.include_router(router)
+
+    client = TestClient(app)
+    resp = client.get("/custom-error")
+    assert resp.status_code == 418, resp.text
+    assert resp.json() == {"error": "something went wrong"}
+
+    resp = client.get("/validation-error?q=notanint")
+    assert resp.status_code == 422, resp.text