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

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: fastapi-deferred-init
-Version: 0.3.3
+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.141.1
+Requires-Python: >=3.11
+Requires-Dist: fastapi>=0.162.0
 Description-Content-Type: text/markdown
 
 # fastapi-deferred-init

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

@@ -12,24 +12,24 @@ authors = [
     { name = "Jan Vollmer", email = "jan@vllmr.dev" },
 ]
 dependencies = [
-    "fastapi>=0.141.1",
+    "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.3"
+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.3 → fastapi_deferred_init-0.3.4}/src/fastapi_deferred_init/patch.py

@@ -1,4 +1,9 @@
-from .routing import DeferringAPIRoute, DeferringAPIRouter, _populate_api_route_state
+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.3 → fastapi_deferred_init-0.3.4}/src/fastapi_deferred_init/routing.py

@@ -26,6 +26,7 @@ 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,
 )
 
@@ -125,10 +126,16 @@ def _populate_api_route_state(
         status_code = int(status_code)
     route.status_code = status_code
 
+    # 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(status_code), (
-                f"Status code {status_code} must not have a response body"
+            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(
@@ -234,11 +241,10 @@ def _populate_api_route_state(
     _add_cache_attribute(route, "is_json_stream", _is_json_stream)
 
     def _resolved_response_model_stream_item(self):
-        nonlocal response_model, stream_item_type
-        resolved_model = response_model
-        resolved_item_type = stream_item_type
-        if isinstance(response_model, DefaultPlaceholder):
-            return_annotation = get_typed_return_annotation(endpoint)
+        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:
@@ -251,8 +257,8 @@ def _populate_api_route_state(
                     # 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)
+                        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
@@ -297,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.3 → 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.3 → fastapi_deferred_init-0.3.4}/tests/test_lib.py

@@ -8,11 +8,10 @@ from fastapi import APIRouter, FastAPI, routing
 from fastapi_deferred_init.routing import (
     DeferringAPIRoute,
     DeferringAPIRouter,
-    _populate_api_route_state,
 )
 
 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):
@@ -20,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)
@@ -124,7 +114,7 @@ def test_fastapi_sse(monkeypatch):
         "fastapi/tests/test_sse.py",
     )
 
-    from fastapi_clone.tests.test_sse import (
+    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

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