fastapi-deferred-init 0.2.10__tar.gz → 0.2.12__tar.gz

{fastapi_deferred_init-0.2.10 → fastapi_deferred_init-0.2.12}/PKG-INFO

@@ -1,14 +1,14 @@
 Metadata-Version: 2.1
 Name: fastapi-deferred-init
-Version: 0.2.10
+Version: 0.2.12
 Summary: Faster FastAPI start-up time for Projects with many nested routers
 Keywords: fastapi,speed,router
 Author-Email: Jan Vollmer <jan@vllmr.dev>
 License: MIT
 Classifier: Framework :: FastAPI
 Project-URL: Source, https://github.com/jvllmr/fastapi-deferred-init
-Requires-Python: >=3.9
-Requires-Dist: fastapi>=0.128.5
+Requires-Python: >=3.10
+Requires-Dist: fastapi>=0.132.0
 Description-Content-Type: text/markdown
 
 # fastapi-deferred-init

{fastapi_deferred_init-0.2.10 → fastapi_deferred_init-0.2.12}/pyproject.toml

@@ -10,15 +10,15 @@ authors = [
     { name = "Jan Vollmer", email = "jan@vllmr.dev" },
 ]
 dependencies = [
-    "fastapi>=0.128.5",
+    "fastapi>=0.132.0",
 ]
-requires-python = ">=3.9"
+requires-python = ">=3.10"
 readme = "README.md"
 classifiers = [
     "Framework :: FastAPI",
 ]
 dynamic = []
-version = "0.2.10"
+version = "0.2.12"
 
 [project.license]
 text = "MIT"
@@ -74,12 +74,12 @@ all = true
 [dependency-groups]
 dev = [
     "pytest>=8.4.2",
-    "ruff>=0.14.7",
+    "ruff>=0.15.2",
     "pre-commit>=4.3.0",
-    "mypy>=1.19.0",
+    "mypy>=1.19.1",
     "tuna>=0.5.11",
     "httpx>=0.28.1",
     "pytest-benchmark>=5.2.3",
-    "pip>=25.3",
-    "inline-snapshot>=0.31.1",
+    "pip>=26.0.1",
+    "inline-snapshot>=0.32.2",
 ]

{fastapi_deferred_init-0.2.10 → fastapi_deferred_init-0.2.12}/src/fastapi_deferred_init/routing.py

@@ -15,7 +15,10 @@ from starlette.routing import Mount as Mount  # noqa
 from starlette.routing import compile_path, get_name
 from starlette.types import ASGIApp, Lifespan
 
-
+from fastapi.sse import (
+    EventSourceResponse,
+    ServerSentEvent,
+)
 from fastapi import params, routing  # type:ignore
 from fastapi._compat import ModelField, lenient_issubclass
 from fastapi.datastructures import Default, DefaultPlaceholder
@@ -26,6 +29,7 @@ from fastapi.dependencies.utils import (
     get_flat_dependant,
     get_parameterless_sub_dependant,
     get_typed_return_annotation,
+    get_stream_item_type,
 )
 from fastapi.responses import JSONResponse, Response
 from fastapi.types import IncEx
@@ -45,42 +49,56 @@ class DeferringAPIRoute(routing.APIRoute):
         endpoint: Callable[..., Any],
         *,
         response_model: Any = Default(None),
-        status_code: Optional[int] = None,
-        tags: Optional[list[Union[str, Enum]]] = None,
-        dependencies: Optional[Sequence[params.Depends]] = None,
-        summary: Optional[str] = None,
-        description: Optional[str] = None,
+        status_code: int | None = None,
+        tags: list[str | Enum] | None = None,
+        dependencies: Sequence[params.Depends] | None = None,
+        summary: str | None = None,
+        description: str | None = None,
         response_description: str = "Successful Response",
-        responses: Optional[dict[Union[int, str], dict[str, Any]]] = None,
-        deprecated: Optional[bool] = None,
-        name: Optional[str] = None,
-        methods: Optional[Union[set[str], list[str]]] = None,
-        operation_id: Optional[str] = None,
-        response_model_include: Optional[IncEx] = None,
-        response_model_exclude: Optional[IncEx] = None,
+        responses: dict[int | str, dict[str, Any]] | None = None,
+        deprecated: bool | None = None,
+        name: str | None = None,
+        methods: set[str] | list[str] | None = None,
+        operation_id: str | None = None,
+        response_model_include: IncEx | None = None,
+        response_model_exclude: IncEx | None = None,
         response_model_by_alias: bool = True,
         response_model_exclude_unset: bool = False,
         response_model_exclude_defaults: bool = False,
         response_model_exclude_none: bool = False,
         include_in_schema: bool = True,
-        response_class: Union[type[Response], DefaultPlaceholder] = Default(
-            JSONResponse
-        ),
-        dependency_overrides_provider: Optional[Any] = None,
-        callbacks: Optional[list[BaseRoute]] = None,
-        openapi_extra: Optional[dict[str, Any]] = None,
-        generate_unique_id_function: Union[
-            Callable[["routing.APIRoute"], str], DefaultPlaceholder
-        ] = Default(generate_unique_id),
+        response_class: type[Response] | DefaultPlaceholder = Default(JSONResponse),
+        dependency_overrides_provider: Any | None = None,
+        callbacks: list[BaseRoute] | None = None,
+        openapi_extra: dict[str, Any] | None = None,
+        generate_unique_id_function: Callable[[routing.APIRoute], str]
+        | DefaultPlaceholder = Default(generate_unique_id),
+        strict_content_type: bool | DefaultPlaceholder = Default(True),
     ) -> None:
         self.path = path
         self.endpoint = endpoint
+        self.stream_item_type: Any | None = None
         if isinstance(response_model, DefaultPlaceholder):
             return_annotation = get_typed_return_annotation(endpoint)
             if lenient_issubclass(return_annotation, Response):
                 response_model = None
             else:
-                response_model = return_annotation
+                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):
+                        self.stream_item_type = stream_item
+                    response_model = None
+                else:
+                    response_model = return_annotation
         self.response_model = response_model
         self.summary = summary
         self.response_description = response_description
@@ -98,6 +116,7 @@ class DeferringAPIRoute(routing.APIRoute):
         self.callbacks = callbacks
         self.openapi_extra = openapi_extra
         self.generate_unique_id_function = generate_unique_id_function
+        self.strict_content_type = strict_content_type
         self.tags = tags or []
         self.responses = responses or {}
         self.name = get_name(endpoint) if name is None else name
@@ -120,8 +139,11 @@ class DeferringAPIRoute(routing.APIRoute):
             assert is_body_allowed_for_status_code(status_code), (
                 f"Status code {status_code} must not have a response body"
             )
+
         self.dependencies = list(dependencies or [])
         self.description = description or inspect.cleandoc(self.endpoint.__doc__ or "")
+        # if a "form feed" character (page break) is found in the description text,
+        # truncate description text to the content preceding the first "form feed"
         self.description = self.description.split("\f")[0].strip()
 
         assert callable(endpoint), "An endpoint must be a callable"
@@ -139,6 +161,20 @@ class DeferringAPIRoute(routing.APIRoute):
             )
         return dependant
 
+    @property
+    def is_generator(self) -> bool:
+        return self.dependant.is_async_gen_callable or self.dependant.is_gen_callable
+
+    @property
+    def is_sse_stream(self) -> bool:
+        return self.is_generator and lenient_issubclass(
+            self.response_class, EventSourceResponse
+        )
+
+    @property
+    def is_json_stream(self) -> bool:
+        return self.is_generator and isinstance(self.response_class, DefaultPlaceholder)
+
     @cached_property
     def _flat_dependant(self):
         return get_flat_dependant(self.dependant)
@@ -159,6 +195,17 @@ class DeferringAPIRoute(routing.APIRoute):
         else:
             return None
 
+    @cached_property
+    def stream_item_field(self) -> ModelField | None:
+        if not self.stream_item_type:
+            return None
+        stream_item_name = "StreamItem_" + self.unique_id
+        return create_model_field(
+            name=stream_item_name,
+            type_=self.stream_item_type,
+            mode="serialization",
+        )
+
     @cached_property
     def response_fields(self) -> dict[Union[int, str], ModelField]:
         response_fields: dict[Union[int, str], ModelField] = {}
@@ -212,6 +259,7 @@ class DeferringAPIRouter(routing.APIRouter):
         generate_unique_id_function: Callable[[routing.APIRoute], str] = Default(
             generate_unique_id
         ),
+        strict_content_type: bool = Default(True),
     ) -> None:
         super().__init__(
             prefix=prefix,
@@ -231,4 +279,5 @@ class DeferringAPIRouter(routing.APIRouter):
             deprecated=deprecated,
             include_in_schema=include_in_schema,
             generate_unique_id_function=generate_unique_id_function,
+            strict_content_type=strict_content_type,
         )

{fastapi_deferred_init-0.2.10 → fastapi_deferred_init-0.2.12}/tests/test_lib.py

@@ -89,3 +89,20 @@ def test_fastapi_openapi_schema(monkeypatch):
 
     fastapi_test_openapi_schema()
     fastapi_test_openapi_schema_additional()
+
+
+def test_fastapi_sse(monkeypatch):
+    monkeypatch.setattr("fastapi.routing.APIRoute", DeferringAPIRoute)
+    monkeypatch.setattr("fastapi.routing.APIRouter", DeferringAPIRouter)
+    import_via_file_path(
+        "fastapi_clone.tests.test_sse",
+        "fastapi/tests/test_sse.py",
+    )
+
+    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_test_raw_data_sent_without_json_encoding(client)