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

fastapi_deferred_init-0.3.1/PKG-INFO

@@ -0,0 +1,64 @@
+Metadata-Version: 2.1
+Name: fastapi-deferred-init
+Version: 0.3.1
+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>
+License: MIT
+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: 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
+Description-Content-Type: text/markdown
+
+# fastapi-deferred-init
+
+![PyPI - Downloads](https://img.shields.io/pypi/dd/fastapi-deferred-init)
+[![GitHub license](https://img.shields.io/github/license/jvllmr/fastapi-deferred-init)](https://github.com/jvllmr/fastapi-deferred-init/blob/master/LICENSE)
+![Tests](https://github.com/jvllmr/fastapi-deferred-init/actions/workflows/test.yml/badge.svg)
+
+## The Problem
+
+When using nested routers in a FastAPI project its start-up time can get long quite fast.
+That is because every router re-calculates the routes defined by a nested router when including it and the pre-calculated values by the nested router never get used. In short: values in nested routers are calculated although they will never be used.
+
+## The Solution
+
+This library provides a modified APIRoute that defers the calculation of values to the first actual attribute access. A router which uses the route as a default is also provided.
+
+## Usage
+
+Older versions of this library worked by simply using custom APIRoute and APIRouter classes, but since FastAPI version 0.137.0 the optimizations require monkey patching to take effect. The following example shows how the patches can be applied by creating an `asgi.py` file as your entrypoint:
+
+```python
+# my_app/asgi.py
+from fastapi_deferred_init import apply_patch
+
+# important! don't import anything else before this to make sure the patch works as expected
+apply_patch()
+
+# run your app with i.e. gunicorn my_app.asgi:app
+from my_app.app import app
+
+# mark app as re-export
+__all__ = ["app"]
+```
+
+## Caveat
+
+When using the deferred APIRoute on every layer of the app, startup errors are deferred to the first time a route is called. So errors related to route registration might go undetected if the route is not tested at least once.
+
+## Pull Request
+
+I created a pull request to merge this change back into FastAPI: https://github.com/tiangolo/fastapi/pull/10589
+It was closed since major refactors to FastAPI are underway, but I might re-open it once the maintainers are ready.

fastapi_deferred_init-0.2.12/PKG-INFO → fastapi_deferred_init-0.3.1/README.md

@@ -1,16 +1,3 @@
-Metadata-Version: 2.1
-Name: fastapi-deferred-init
-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.10
-Requires-Dist: fastapi>=0.132.0
-Description-Content-Type: text/markdown
-
 # fastapi-deferred-init
 
 ![PyPI - Downloads](https://img.shields.io/pypi/dd/fastapi-deferred-init)
@@ -26,6 +13,24 @@ That is because every router re-calculates the routes defined by a nested router
 
 This library provides a modified APIRoute that defers the calculation of values to the first actual attribute access. A router which uses the route as a default is also provided.
 
+## Usage
+
+Older versions of this library worked by simply using custom APIRoute and APIRouter classes, but since FastAPI version 0.137.0 the optimizations require monkey patching to take effect. The following example shows how the patches can be applied by creating an `asgi.py` file as your entrypoint:
+
+```python
+# my_app/asgi.py
+from fastapi_deferred_init import apply_patch
+
+# important! don't import anything else before this to make sure the patch works as expected
+apply_patch()
+
+# run your app with i.e. gunicorn my_app.asgi:app
+from my_app.app import app
+
+# mark app as re-export
+__all__ = ["app"]
+```
+
 ## Caveat
 
 When using the deferred APIRoute on every layer of the app, startup errors are deferred to the first time a route is called. So errors related to route registration might go undetected if the route is not tested at least once.
@@ -33,3 +38,4 @@ When using the deferred APIRoute on every layer of the app, startup errors are d
 ## Pull Request
 
 I created a pull request to merge this change back into FastAPI: https://github.com/tiangolo/fastapi/pull/10589
+It was closed since major refactors to FastAPI are underway, but I might re-open it once the maintainers are ready.

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

@@ -5,26 +5,38 @@ keywords = [
     "fastapi",
     "speed",
     "router",
+    "startup",
+    "optimization",
 ]
 authors = [
     { name = "Jan Vollmer", email = "jan@vllmr.dev" },
 ]
 dependencies = [
-    "fastapi>=0.132.0",
+    "fastapi>=0.139.0",
 ]
 requires-python = ">=3.10"
 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",
+    "Typing :: Typed",
 ]
 dynamic = []
-version = "0.2.12"
+version = "0.3.1"
 
 [project.license]
 text = "MIT"
 
 [project.urls]
 Source = "https://github.com/jvllmr/fastapi-deferred-init"
+Changelog = "https://github.com/jvllmr/fastapi-deferred-init/releases"
 
 [build-system]
 requires = [
@@ -73,13 +85,13 @@ all = true
 
 [dependency-groups]
 dev = [
-    "pytest>=8.4.2",
-    "ruff>=0.15.2",
+    "pytest>=9.1.1",
+    "ruff>=0.15.20",
     "pre-commit>=4.3.0",
-    "mypy>=1.19.1",
-    "tuna>=0.5.11",
-    "httpx>=0.28.1",
+    "mypy>=2.1.0",
+    "tuna>=0.5.15",
     "pytest-benchmark>=5.2.3",
-    "pip>=26.0.1",
-    "inline-snapshot>=0.32.2",
+    "pip>=26.1.2",
+    "inline-snapshot>=0.34.2",
+    "httpx2>=2.9.1",
 ]

fastapi_deferred_init-0.3.1/src/fastapi_deferred_init/__init__.py

@@ -0,0 +1,3 @@
+from .patch import apply_patch
+
+__all__ = ["apply_patch"]

fastapi_deferred_init-0.3.1/src/fastapi_deferred_init/patch.py

@@ -0,0 +1,14 @@
+from .routing import _populate_api_route_state, DeferringAPIRoute, DeferringAPIRouter
+
+
+def apply_patch() -> None:
+
+    from fastapi import routing  # type: ignore[attr-defined]
+
+    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]
+
+    import fastapi
+
+    fastapi.APIRouter = DeferringAPIRouter  # type:ignore[attr-defined]  # ty:ignore[invalid-assignment]

fastapi_deferred_init-0.3.1/src/fastapi_deferred_init/routing.py

@@ -0,0 +1,272 @@
+from fastapi.dependencies.models import Dependant
+import inspect
+from enum import Enum, IntEnum
+from functools import cached_property
+from typing import Any, Callable, Union, cast
+from collections.abc import Sequence
+
+
+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.utils import (
+    _should_embed_body_fields,
+    get_body_field,
+    get_dependant,
+    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
+from fastapi.utils import (
+    create_model_field,
+    generate_unique_id,
+    is_body_allowed_for_status_code,
+)
+
+
+def _add_cache_attribute(
+    instance: routing._APIRouteLike, name: str, func: Callable[[Any], Any]
+) -> None:
+    cls = type(instance)
+
+    if name in instance.__dict__ and (
+        (val := instance.__dict__[name]) is None or val is False
+    ):
+        delattr(instance, name)
+
+    # replace attribute with cached_property
+    if not hasattr(cls, name) or not isinstance(getattr(cls, name), cached_property):
+        prop = cached_property(func)
+        setattr(cls, name, prop)
+        prop.__set_name__(cls, name)
+
+
+def _populate_api_route_state(
+    route: routing._APIRouteLike,
+    path: str,
+    endpoint: Callable[..., Any],
+    *,
+    response_model: Any = Default(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: 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: type[Response] | DefaultPlaceholder = Default(JSONResponse),
+    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
+    ),
+    strict_content_type: bool | DefaultPlaceholder = Default(True),
+) -> 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.summary = summary
+    route.response_description = response_description
+    route.deprecated = deprecated
+    route.operation_id = operation_id
+    route.response_model_include = response_model_include
+    route.response_model_exclude = response_model_exclude
+    route.response_model_by_alias = response_model_by_alias
+    route.response_model_exclude_unset = response_model_exclude_unset
+    route.response_model_exclude_defaults = response_model_exclude_defaults
+    route.response_model_exclude_none = response_model_exclude_none
+    route.include_in_schema = include_in_schema
+    route.response_class = response_class
+    route.dependency_overrides_provider = dependency_overrides_provider
+    route.callbacks = callbacks
+    route.openapi_extra = openapi_extra
+    route.generate_unique_id_function = generate_unique_id_function
+    route.strict_content_type = strict_content_type
+    route.tags = tags or []
+    route.responses = responses or {}
+    route.name = routing.get_name(endpoint) if name is None else name
+    route.path_regex, route.path_format, route.param_convertors = routing.compile_path(
+        path
+    )
+    if methods is None:
+        methods = ["GET"]
+    route.methods = {method.upper() for method in methods}
+    if isinstance(generate_unique_id_function, DefaultPlaceholder):
+        current_generate_unique_id: Callable[[Any], str] = (
+            generate_unique_id_function.value
+        )
+    else:
+        current_generate_unique_id = generate_unique_id_function
+    route.unique_id = route.operation_id or current_generate_unique_id(route)
+    # normalize enums e.g. http.HTTPStatus
+    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:
+            response_name = "Response_" + self.unique_id
+            return create_model_field(
+                name=response_name,
+                type_=self.response_model,
+                mode="serialization",
+            )
+        else:
+            return None
+
+    _add_cache_attribute(route, "response_field", _response_field)
+
+    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",
+        )
+
+    _add_cache_attribute(route, "stream_item_field", _stream_item_field)
+
+    route.dependencies = list(dependencies or [])
+    route.description = description or inspect.cleandoc(route.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"
+    route.description = route.description.split("\f")[0].strip()
+
+    def _response_fields(self) -> dict[Union[int, str], ModelField]:
+        response_fields: dict[Union[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")
+            if model:
+                assert is_body_allowed_for_status_code(additional_status_code), (
+                    f"Status code {additional_status_code} must not have a response body"
+                )
+                response_name = f"Response_{additional_status_code}_{self.unique_id}"
+                response_field = create_model_field(
+                    name=response_name, type_=model, mode="serialization"
+                )
+                response_fields[additional_status_code] = response_field
+        return response_fields
+
+    _add_cache_attribute(route, "response_fields", _response_fields)
+
+    assert callable(endpoint), "An endpoint must be a callable"
+
+    def _get_dependant(self: routing._APIRouteLike) -> Dependant:
+        dependant = get_dependant(
+            path=self.path_format, call=self.endpoint, scope="function"
+        )
+
+        for depends in self.dependencies[::-1]:
+            dependant.dependencies.insert(
+                0,
+                get_parameterless_sub_dependant(depends=depends, path=self.path_format),
+            )
+
+        return dependant
+
+    _add_cache_attribute(route, "dependant", _get_dependant)
+
+    def _get_flat_dependant(self) -> Dependant:
+        return get_flat_dependant(self.dependant)
+
+    _add_cache_attribute(route, "_flat_dependant", _get_flat_dependant)
+
+    def _embed_body_fields(self):
+        return _should_embed_body_fields(self._flat_dependant.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,
+            name=self.unique_id,
+            embed_body_fields=self._embed_body_fields,
+        )
+
+    _add_cache_attribute(route, "body_field", _body_field)
+
+    # 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
+
+    _add_cache_attribute(route, "is_generator", _is_generator)
+
+    def _is_sse_stream(self) -> bool:
+        return self.is_generator and lenient_issubclass(
+            self.response_class, EventSourceResponse
+        )
+
+    _add_cache_attribute(route, "is_sse_stream", _is_sse_stream)
+
+    def _is_json_stream(self) -> bool:
+        return self.is_generator and isinstance(self.response_class, DefaultPlaceholder)
+
+    _add_cache_attribute(route, "is_json_stream", _is_json_stream)
+
+
+class DeferringAPIRoute(routing.APIRoute):
+    def __init__(
+        self, path: str, endpoint: Callable[..., Any], *args, **kwargs
+    ) -> None:
+        _populate_api_route_state(
+            cast(routing._APIRouteLike, self), path, endpoint, *args, **kwargs
+        )
+
+    @cached_property
+    def app(self):
+        return routing.request_response(self.get_route_handler())
+
+
+class DeferringAPIRouter(routing.APIRouter):
+    def __init__(self, *args, **kwargs):
+        if "route_class" not in kwargs:
+            kwargs["route_class"] = DeferringAPIRoute
+        super().__init__(*args, **kwargs)

{fastapi_deferred_init-0.2.12 → fastapi_deferred_init-0.3.1}/tests/data/gen_code_ast.py

@@ -13,11 +13,6 @@ base_module = ast.Module(
             names=[ast.alias(name="JSONResponse")],
             level=0,
         ),
-        ast.ImportFrom(
-            module="fastapi_deferred_init",
-            names=[ast.alias(name="DeferringAPIRouter")],
-            level=0,
-        ),
         ast.Assign(
             targets=[ast.Name(id="dependency0", ctx=ast.Store())],
             value=ast.Lambda(
@@ -58,14 +53,12 @@ def gen_func_def(n=1, last=False):
     )
 
 
-def gen_router(n=2, last=False, use_lib=True):
+def gen_router(n=2, last=False):
     return [
         ast.Assign(
             targets=[ast.Name(id=f"router{'' if last else n}", ctx=ast.Store())],
             value=ast.Call(
-                func=ast.Name(
-                    id="DeferringAPIRouter" if use_lib else "APIRouter", ctx=ast.Load()
-                ),
+                func=ast.Name(id="APIRouter", ctx=ast.Load()),
                 args=[],
                 keywords=[
                     ast.keyword(
@@ -151,7 +144,9 @@ def gen_router(n=2, last=False, use_lib=True):
     )
 
 
-def get_tree(n=1000, use_lib=True):
+def get_tree(
+    n=1000,
+):
     module = copy.deepcopy(base_module)
     for i in range(1, n + 1):
         module.body.append(gen_func_def(i))
@@ -159,16 +154,24 @@ def get_tree(n=1000, use_lib=True):
     module.body.append(gen_func_def(i + 1, True))
 
     for i in range(n):
-        module.body.extend(gen_router(i, use_lib=use_lib))
+        module.body.extend(
+            gen_router(
+                i,
+            )
+        )
 
-    module.body.extend(gen_router(i + 1, True, use_lib))
+    module.body.extend(gen_router(i + 1, True))
 
     ast.fix_missing_locations(module)
     return module
 
 
-def create_code(n=1000, use_lib=True):
-    tree = get_tree(n, use_lib)
+def create_code(
+    n=1000,
+):
+    tree = get_tree(
+        n,
+    )
 
     with open("tests/data/code.py", "w") as f:
         f.write(ast.unparse(tree))

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

@@ -2,12 +2,15 @@ import os
 
 import pytest
 from pydantic import BaseModel
-from starlette.routing import Route
 
-from fastapi import APIRouter, FastAPI
-from fastapi.routing import APIRoute
+from fastapi import FastAPI, APIRouter
+from fastapi import routing
 from fastapi.testclient import TestClient
-from fastapi_deferred_init import DeferringAPIRoute, DeferringAPIRouter
+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
@@ -18,34 +21,52 @@ 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):
+def test_basic(use_lib: bool, benchmark, monkeypatch):
     skip_test(use_lib=use_lib)
-    create_code(50, use_lib=use_lib)  # switch bool to compare
+    if use_lib:
+        apply_monkeypatch(monkeypatch)
+    create_code(
+        50,
+    )
 
     generated_code = benchmark(load_code)
-
+    assert generated_code.APIRouter is (DeferringAPIRouter if use_lib else APIRouter)
     app = FastAPI()
     router = generated_code.router
 
     app.include_router(router)
 
-    assert type(router) is (DeferringAPIRouter if use_lib else APIRouter)
     client = TestClient(app)
-    assert len(app.routes) == 54
-    for route in app.routes:
-        if route in router.routes:
-            assert type(route) is (DeferringAPIRoute if use_lib else APIRoute)
-        assert isinstance(route, Route)
+    routes = list(routing.iter_route_contexts(app.routes))
+    assert len(routes) == 54
+    for route in routes:
+        if not route.path or route.path in ("/openapi.json"):
+            continue
         resp = client.get(route.path)
         assert resp.status_code == 200
 
 
 @pytest.mark.parametrize(["use_lib"], [(True,), (False,)])
-def test_with_pydantic_model(use_lib: bool):
+def test_with_pydantic_model(use_lib: bool, monkeypatch):
+
     skip_test(use_lib=use_lib)
+    if use_lib:
+        apply_monkeypatch(monkeypatch)
     app = FastAPI()
-    router = DeferringAPIRouter() if use_lib else APIRouter()
+    router = routing.APIRouter()
+    assert isinstance(router, DeferringAPIRouter if use_lib else routing.APIRouter), (
+        type(router)
+    )
 
     class Login(BaseModel):
         username: str
@@ -59,6 +80,12 @@ def test_with_pydantic_model(use_lib: bool):
 
         return {"userdata": "[...]"}
 
+    assert isinstance(
+        router.routes[0], DeferringAPIRoute if use_lib else routing.APIRoute
+    ), (
+        router.routes,
+        type(router.routes[0]),
+    )
     app.include_router(router)
 
     client = TestClient(app)
@@ -68,8 +95,8 @@ def test_with_pydantic_model(use_lib: bool):
 
 
 def test_fastapi_openapi_schema(monkeypatch):
-    monkeypatch.setattr("fastapi.routing.APIRoute", DeferringAPIRoute)
-    monkeypatch.setattr("fastapi.routing.APIRouter", DeferringAPIRouter)
+    apply_monkeypatch(monkeypatch)
+
     import_via_file_path(
         "fastapi_clone.tests.test_additional_properties",
         "fastapi/tests/test_additional_properties.py",
@@ -92,8 +119,7 @@ def test_fastapi_openapi_schema(monkeypatch):
 
 
 def test_fastapi_sse(monkeypatch):
-    monkeypatch.setattr("fastapi.routing.APIRoute", DeferringAPIRoute)
-    monkeypatch.setattr("fastapi.routing.APIRouter", DeferringAPIRouter)
+    apply_monkeypatch(monkeypatch)
     import_via_file_path(
         "fastapi_clone.tests.test_sse",
         "fastapi/tests/test_sse.py",

fastapi_deferred_init-0.2.12/README.md

@@ -1,22 +0,0 @@
-# fastapi-deferred-init
-
-![PyPI - Downloads](https://img.shields.io/pypi/dd/fastapi-deferred-init)
-[![GitHub license](https://img.shields.io/github/license/jvllmr/fastapi-deferred-init)](https://github.com/jvllmr/fastapi-deferred-init/blob/master/LICENSE)
-![Tests](https://github.com/jvllmr/fastapi-deferred-init/actions/workflows/test.yml/badge.svg)
-
-## The Problem
-
-When using nested routers in a FastAPI project its start-up time can get long quite fast.
-That is because every router re-calculates the routes defined by a nested router when including it and the pre-calculated values by the nested router never get used. In short: values in nested routers are calculated although they will never be used.
-
-## The Solution
-
-This library provides a modified APIRoute that defers the calculation of values to the first actual attribute access. A router which uses the route as a default is also provided.
-
-## Caveat
-
-When using the deferred APIRoute on every layer of the app, startup errors are deferred to the first time a route is called. So errors related to route registration might go undetected if the route is not tested at least once.
-
-## Pull Request
-
-I created a pull request to merge this change back into FastAPI: https://github.com/tiangolo/fastapi/pull/10589

fastapi_deferred_init-0.2.12/src/fastapi_deferred_init/__init__.py

@@ -1,3 +0,0 @@
-from .routing import DeferringAPIRoute, DeferringAPIRouter
-
-__all__ = ["DeferringAPIRoute", "DeferringAPIRouter"]

fastapi_deferred_init-0.2.12/src/fastapi_deferred_init/routing.py

@@ -1,283 +0,0 @@
-import inspect
-from enum import Enum, IntEnum
-from functools import cached_property
-from typing import (
-    Any,
-    Callable,
-    ClassVar,
-    Optional,
-    Union,
-)
-from collections.abc import Sequence
-
-from starlette.routing import BaseRoute
-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
-from fastapi.dependencies.utils import (
-    _should_embed_body_fields,
-    get_body_field,
-    get_dependant,
-    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
-from fastapi.utils import (
-    create_model_field,
-    generate_unique_id,
-    is_body_allowed_for_status_code,
-)
-
-
-class DeferringAPIRoute(routing.APIRoute):
-    _getattr: ClassVar[Callable[[Any, str], Any]]
-
-    def __init__(
-        self,
-        path: str,
-        endpoint: Callable[..., Any],
-        *,
-        response_model: Any = Default(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: 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: 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:
-                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
-        self.deprecated = deprecated
-        self.operation_id = operation_id
-        self.response_model_include = response_model_include
-        self.response_model_exclude = response_model_exclude
-        self.response_model_by_alias = response_model_by_alias
-        self.response_model_exclude_unset = response_model_exclude_unset
-        self.response_model_exclude_defaults = response_model_exclude_defaults
-        self.response_model_exclude_none = response_model_exclude_none
-        self.include_in_schema = include_in_schema
-        self.response_class = response_class
-        self.dependency_overrides_provider = dependency_overrides_provider
-        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
-        self.path_regex, self.path_format, self.param_convertors = compile_path(path)
-        if methods is None:
-            methods = ["GET"]
-        self.methods: set[str] = {method.upper() for method in methods}
-        if isinstance(generate_unique_id_function, DefaultPlaceholder):
-            current_generate_unique_id: Callable[[routing.APIRoute], str] = (
-                generate_unique_id_function.value
-            )
-        else:
-            current_generate_unique_id = generate_unique_id_function
-        self.unique_id = self.operation_id or current_generate_unique_id(self)
-        # normalize enums e.g. http.HTTPStatus
-        if isinstance(status_code, IntEnum):
-            status_code = int(status_code)
-        self.status_code = status_code
-        if self.response_model:
-            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"
-
-    @cached_property
-    def dependant(self):
-        dependant = get_dependant(
-            path=self.path_format, call=self.endpoint, scope="function"
-        )
-
-        for depends in self.dependencies[::-1]:
-            dependant.dependencies.insert(
-                0,
-                get_parameterless_sub_dependant(depends=depends, path=self.path_format),
-            )
-        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)
-
-    @cached_property
-    def _embed_body_fields(self):
-        return _should_embed_body_fields(self._flat_dependant.body_params)
-
-    @cached_property
-    def response_field(self):
-        if self.response_model:
-            response_name = "Response_" + self.unique_id
-            return create_model_field(
-                name=response_name,
-                type_=self.response_model,
-                mode="serialization",
-            )
-        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] = {}
-        for additional_status_code, response in self.responses.items():
-            assert isinstance(response, dict), "An additional response must be a dict"
-            model = response.get("model")
-            if model:
-                assert is_body_allowed_for_status_code(additional_status_code), (
-                    f"Status code {additional_status_code} must not have a response body"
-                )
-                response_name = f"Response_{additional_status_code}_{self.unique_id}"
-                response_field = create_model_field(
-                    name=response_name, type_=model, mode="serialization"
-                )
-                response_fields[additional_status_code] = response_field
-        return response_fields
-
-    @cached_property
-    def body_field(self):
-        return get_body_field(
-            flat_dependant=self._flat_dependant,
-            name=self.unique_id,
-            embed_body_fields=self._embed_body_fields,
-        )
-
-    @cached_property
-    def app(self):
-        return routing.request_response(self.get_route_handler())
-
-
-class DeferringAPIRouter(routing.APIRouter):
-    def __init__(
-        self,
-        *,
-        prefix: str = "",
-        tags: Optional[list[Union[str, Enum]]] = None,
-        dependencies: Optional[Sequence[params.Depends]] = None,
-        default_response_class: type[Response] = Default(JSONResponse),
-        responses: Optional[dict[Union[int, str], dict[str, Any]]] = None,
-        callbacks: Optional[list[BaseRoute]] = None,
-        routes: Optional[list[BaseRoute]] = None,
-        redirect_slashes: bool = True,
-        default: Optional[ASGIApp] = None,
-        dependency_overrides_provider: Optional[Any] = None,
-        route_class: type[routing.APIRoute] = DeferringAPIRoute,
-        on_startup: Optional[Sequence[Callable[[], Any]]] = None,
-        on_shutdown: Optional[Sequence[Callable[[], Any]]] = None,
-        lifespan: Optional[Lifespan[Any]] = None,
-        deprecated: Optional[bool] = None,
-        include_in_schema: bool = True,
-        generate_unique_id_function: Callable[[routing.APIRoute], str] = Default(
-            generate_unique_id
-        ),
-        strict_content_type: bool = Default(True),
-    ) -> None:
-        super().__init__(
-            prefix=prefix,
-            tags=tags,
-            dependencies=dependencies,
-            default_response_class=default_response_class,
-            responses=responses,
-            callbacks=callbacks,
-            routes=routes,
-            redirect_slashes=redirect_slashes,
-            default=default,
-            dependency_overrides_provider=dependency_overrides_provider,
-            route_class=route_class,
-            on_startup=on_startup,
-            on_shutdown=on_shutdown,
-            lifespan=lifespan,
-            deprecated=deprecated,
-            include_in_schema=include_in_schema,
-            generate_unique_id_function=generate_unique_id_function,
-            strict_content_type=strict_content_type,
-        )