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

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

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

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

@@ -12,7 +12,7 @@ authors = [
     { name = "Jan Vollmer", email = "jan@vllmr.dev" },
 ]
 dependencies = [
-    "fastapi>=0.139.0",
+    "fastapi>=0.141.1",
 ]
 requires-python = ">=3.10"
 readme = "README.md"
@@ -29,7 +29,7 @@ classifiers = [
     "Typing :: Typed",
 ]
 dynamic = []
-version = "0.3.1"
+version = "0.3.3"
 
 [project.license]
 text = "MIT"

{fastapi_deferred_init-0.3.1 → fastapi_deferred_init-0.3.3}/src/fastapi_deferred_init/patch.py

@@ -1,4 +1,4 @@
-from .routing import _populate_api_route_state, DeferringAPIRoute, DeferringAPIRouter
+from .routing import DeferringAPIRoute, DeferringAPIRouter, _populate_api_route_state
 
 
 def apply_patch() -> None:

{fastapi_deferred_init-0.3.1 → fastapi_deferred_init-0.3.3}/src/fastapi_deferred_init/routing.py

@@ -1,28 +1,27 @@
-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 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 (
+    _get_body_field,
+    _get_flat_body_params,
     _should_embed_body_fields,
-    get_body_field,
     get_dependant,
-    get_flat_dependant,
     get_parameterless_sub_dependant,
-    get_typed_return_annotation,
     get_stream_item_type,
+    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,
@@ -30,6 +29,8 @@ from fastapi.utils import (
     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]
@@ -53,7 +54,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,
@@ -72,40 +73,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
@@ -143,13 +124,12 @@ 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"
-        )
 
     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"
+            )
             response_name = "Response_" + self.unique_id
             return create_model_field(
                 name=response_name,
@@ -179,8 +159,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")
@@ -214,20 +194,20 @@ def _populate_api_route_state(
 
     _add_cache_attribute(route, "dependant", _get_dependant)
 
-    def _get_flat_dependant(self) -> Dependant:
-        return get_flat_dependant(self.dependant)
+    def _flat_body_params(self) -> list[ModelField]:
+        return _get_flat_body_params(self.dependant)
 
-    _add_cache_attribute(route, "_flat_dependant", _get_flat_dependant)
+    _add_cache_attribute(route, "_flat_body_params", _flat_body_params)
 
     def _embed_body_fields(self):
-        return _should_embed_body_fields(self._flat_dependant.body_params)
+        return _should_embed_body_fields(self._flat_body_params)
 
     _add_cache_attribute(route, "_embed_body_fields", _embed_body_fields)
 
     def _body_field(self):
-        return get_body_field(
-            flat_dependant=self._flat_dependant,
+        return _get_body_field(
             name=self.unique_id,
+            body_params=self._flat_body_params,
             embed_body_fields=self._embed_body_fields,
         )
 
@@ -235,7 +215,9 @@ def _populate_api_route_state(
 
     # Detect generator endpoints that should stream as JSONL or SSE
     def _is_generator(self) -> bool:
-        return self.dependant.is_async_gen_callable or self.dependant.is_gen_callable
+        return _is_async_gen_callable(self.dependant.call) or _is_gen_callable(
+            self.dependant.call
+        )
 
     _add_cache_attribute(route, "is_generator", _is_generator)
 
@@ -251,6 +233,51 @@ 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)
+            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(response_class, DefaultPlaceholder)
+                        or lenient_issubclass(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__(

{fastapi_deferred_init-0.3.1 → fastapi_deferred_init-0.3.3}/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.1 → fastapi_deferred_init-0.3.3}/tests/test_lib.py

@@ -1,15 +1,14 @@
 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,
+    _populate_api_route_state,
 )
 
 from .data.gen_code_ast import create_code
@@ -107,10 +106,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 +124,11 @@ def test_fastapi_sse(monkeypatch):
         "fastapi/tests/test_sse.py",
     )
 
+    from fastapi_clone.tests.test_sse 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__():