microbootstrap 0__py3-none-any.whl

microbootstrap/__init__.py

@@ -0,0 +1,44 @@
+from microbootstrap.instruments.cors_instrument import CorsConfig
+from microbootstrap.instruments.health_checks_instrument import HealthChecksConfig
+from microbootstrap.instruments.logging_instrument import LoggingConfig
+from microbootstrap.instruments.opentelemetry_instrument import (
+    FastStreamOpentelemetryConfig,
+    FastStreamTelemetryMiddlewareProtocol,
+    OpentelemetryConfig,
+)
+from microbootstrap.instruments.prometheus_instrument import (
+    FastApiPrometheusConfig,
+    FastStreamPrometheusConfig,
+    FastStreamPrometheusMiddlewareProtocol,
+    LitestarPrometheusConfig,
+)
+from microbootstrap.instruments.pyroscope_instrument import PyroscopeConfig
+from microbootstrap.instruments.sentry_instrument import SentryConfig
+from microbootstrap.instruments.swagger_instrument import SwaggerConfig
+from microbootstrap.settings import (
+    FastApiSettings,
+    FastStreamSettings,
+    InstrumentsSetupperSettings,
+    LitestarSettings,
+)
+
+
+__all__ = (
+    "CorsConfig",
+    "FastApiPrometheusConfig",
+    "FastApiSettings",
+    "FastStreamOpentelemetryConfig",
+    "FastStreamPrometheusConfig",
+    "FastStreamPrometheusMiddlewareProtocol",
+    "FastStreamSettings",
+    "FastStreamTelemetryMiddlewareProtocol",
+    "HealthChecksConfig",
+    "InstrumentsSetupperSettings",
+    "LitestarPrometheusConfig",
+    "LitestarSettings",
+    "LoggingConfig",
+    "OpentelemetryConfig",
+    "PyroscopeConfig",
+    "SentryConfig",
+    "SwaggerConfig",
+)

microbootstrap/bootstrappers/base.py

@@ -0,0 +1,114 @@
+from __future__ import annotations
+import abc
+import typing
+
+from microbootstrap.console_writer import ConsoleWriter
+from microbootstrap.helpers import dataclass_to_dict_no_defaults, merge_dataclasses_configs, merge_dict_configs
+from microbootstrap.instruments.instrument_box import InstrumentBox
+from microbootstrap.settings import SettingsT
+
+
+if typing.TYPE_CHECKING:
+    import typing_extensions
+
+    from microbootstrap.instruments.base import Instrument, InstrumentConfigT
+
+
+class DataclassInstance(typing.Protocol):
+    __dataclass_fields__: typing.ClassVar[dict[str, typing.Any]]
+
+
+ApplicationT = typing.TypeVar("ApplicationT", bound=typing.Any)
+DataclassT = typing.TypeVar("DataclassT", bound=DataclassInstance)
+
+
+class ApplicationBootstrapper(abc.ABC, typing.Generic[SettingsT, ApplicationT, DataclassT]):
+    application_type: type[ApplicationT]
+    application_config: DataclassT
+    console_writer: ConsoleWriter
+    instrument_box: InstrumentBox
+
+    def __init__(self, settings: SettingsT) -> None:
+        self.settings = settings
+        self.console_writer = ConsoleWriter(writer_enabled=settings.service_debug)
+
+        if not hasattr(self, "instrument_box"):
+            self.instrument_box = InstrumentBox()
+        self.instrument_box.initialize(self.settings)
+
+    def configure_application(
+        self,
+        application_config: DataclassT,
+    ) -> typing_extensions.Self:
+        self.application_config = merge_dataclasses_configs(self.application_config, application_config)
+        return self
+
+    def configure_instrument(
+        self,
+        instrument_config: InstrumentConfigT,
+    ) -> typing_extensions.Self:
+        self.instrument_box.configure_instrument(instrument_config)
+        return self
+
+    def configure_instruments(
+        self,
+        *instrument_configs: InstrumentConfigT,
+    ) -> typing_extensions.Self:
+        for instrument_config in instrument_configs:
+            self.configure_instrument(instrument_config)
+        return self
+
+    @classmethod
+    def use_instrument(
+        cls,
+    ) -> typing.Callable[
+        [type[Instrument[InstrumentConfigT]]],
+        type[Instrument[InstrumentConfigT]],
+    ]:
+        if not hasattr(cls, "instrument_box"):
+            cls.instrument_box = InstrumentBox()
+        return cls.instrument_box.extend_instruments
+
+    def bootstrap(self) -> ApplicationT:
+        resulting_application_config: dict[str, typing.Any] = {}
+        for instrument in self.instrument_box.instruments:
+            if instrument.is_ready():
+                instrument.bootstrap()
+                resulting_application_config = merge_dict_configs(
+                    resulting_application_config,
+                    instrument.bootstrap_before(),
+                )
+            instrument.write_status(self.console_writer)
+
+        resulting_application_config = merge_dict_configs(
+            resulting_application_config,
+            dataclass_to_dict_no_defaults(self.application_config),
+        )
+        application = self.application_type(
+            **merge_dict_configs(resulting_application_config, self.bootstrap_before()),
+        )
+
+        self.bootstrap_before_instruments_after_app_created(application)
+
+        for instrument in self.instrument_box.instruments:
+            if instrument.is_ready():
+                application = instrument.bootstrap_after(application)
+
+        return self.bootstrap_after(application)
+
+    def bootstrap_before(self) -> dict[str, typing.Any]:
+        """Add some framework-related parameters to final bootstrap result before application creation."""
+        return {}
+
+    def bootstrap_before_instruments_after_app_created(self, application: ApplicationT) -> ApplicationT:
+        """Add some framework-related parameters to bootstrap result after application creation, but before instruments are applied."""  # noqa: E501
+        return application
+
+    def bootstrap_after(self, application: ApplicationT) -> ApplicationT:
+        """Add some framework-related parameters to final bootstrap result after application creation."""
+        return application
+
+    def teardown(self) -> None:
+        for instrument in self.instrument_box.instruments:
+            if instrument.is_ready():
+                instrument.teardown()

microbootstrap/bootstrappers/fastapi.py

@@ -0,0 +1,148 @@
+import contextlib
+import typing
+
+import fastapi
+from fastapi.middleware.cors import CORSMiddleware
+from fastapi_offline_docs import enable_offline_docs
+from opentelemetry.instrumentation.fastapi import FastAPIInstrumentor
+from prometheus_fastapi_instrumentator import Instrumentator
+
+from microbootstrap.bootstrappers.base import ApplicationBootstrapper
+from microbootstrap.config.fastapi import FastApiConfig
+from microbootstrap.instruments.cors_instrument import CorsInstrument
+from microbootstrap.instruments.health_checks_instrument import HealthChecksInstrument, HealthCheckTypedDict
+from microbootstrap.instruments.logging_instrument import LoggingInstrument
+from microbootstrap.instruments.opentelemetry_instrument import OpentelemetryInstrument
+from microbootstrap.instruments.prometheus_instrument import FastApiPrometheusConfig, PrometheusInstrument
+from microbootstrap.instruments.pyroscope_instrument import PyroscopeInstrument
+from microbootstrap.instruments.sentry_instrument import SentryInstrument
+from microbootstrap.instruments.swagger_instrument import SwaggerInstrument
+from microbootstrap.middlewares.fastapi import build_fastapi_logging_middleware
+from microbootstrap.settings import FastApiSettings
+
+
+ApplicationT = typing.TypeVar("ApplicationT", bound=fastapi.FastAPI)
+
+
+class FastApiBootstrapper(
+    ApplicationBootstrapper[FastApiSettings, fastapi.FastAPI, FastApiConfig],
+):
+    application_config = FastApiConfig()
+    application_type = fastapi.FastAPI
+
+    @contextlib.asynccontextmanager
+    async def _lifespan_manager(self, _: fastapi.FastAPI) -> typing.AsyncIterator[None]:
+        try:
+            self.console_writer.print_bootstrap_table()
+            yield
+        finally:
+            self.teardown()
+
+    @contextlib.asynccontextmanager
+    async def _wrapped_lifespan_manager(self, app: fastapi.FastAPI) -> typing.AsyncIterator[None]:
+        assert self.application_config.lifespan  # noqa: S101
+        async with self._lifespan_manager(app), self.application_config.lifespan(app):
+            yield None
+
+    def bootstrap_before(self) -> dict[str, typing.Any]:
+        return {
+            "debug": self.settings.service_debug,
+            "lifespan": self._wrapped_lifespan_manager if self.application_config.lifespan else self._lifespan_manager,
+        }
+
+
+FastApiBootstrapper.use_instrument()(SentryInstrument)
+
+
+@FastApiBootstrapper.use_instrument()
+class FastApiSwaggerInstrument(SwaggerInstrument):
+    def bootstrap_before(self) -> dict[str, typing.Any]:
+        return {
+            "title": self.instrument_config.service_name,
+            "description": self.instrument_config.service_description,
+            "docs_url": self.instrument_config.swagger_path,
+            "version": self.instrument_config.service_version,
+        }
+
+    def bootstrap_after(self, application: ApplicationT) -> ApplicationT:
+        if self.instrument_config.swagger_offline_docs:
+            enable_offline_docs(application, static_files_handler=self.instrument_config.service_static_path)
+        return application
+
+
+@FastApiBootstrapper.use_instrument()
+class FastApiCorsInstrument(CorsInstrument):
+    def bootstrap_after(self, application: ApplicationT) -> ApplicationT:
+        application.add_middleware(
+            CORSMiddleware,
+            allow_origins=self.instrument_config.cors_allowed_origins,
+            allow_methods=self.instrument_config.cors_allowed_methods,
+            allow_headers=self.instrument_config.cors_allowed_headers,
+            allow_credentials=self.instrument_config.cors_allowed_credentials,
+            allow_origin_regex=self.instrument_config.cors_allowed_origin_regex,
+            expose_headers=self.instrument_config.cors_exposed_headers,
+            max_age=self.instrument_config.cors_max_age,
+        )
+        return application
+
+
+FastApiBootstrapper.use_instrument()(PyroscopeInstrument)
+
+
+@FastApiBootstrapper.use_instrument()
+class FastApiOpentelemetryInstrument(OpentelemetryInstrument):
+    def bootstrap_after(self, application: ApplicationT) -> ApplicationT:
+        FastAPIInstrumentor.instrument_app(
+            application,
+            tracer_provider=self.tracer_provider,
+            excluded_urls=",".join(self.define_exclude_urls()),
+        )
+        return application
+
+
+@FastApiBootstrapper.use_instrument()
+class FastApiLoggingInstrument(LoggingInstrument):
+    def bootstrap_after(self, application: ApplicationT) -> ApplicationT:
+        if not self.instrument_config.logging_turn_off_middleware:
+            application.add_middleware(
+                build_fastapi_logging_middleware(self.instrument_config.logging_exclude_endpoints),
+            )
+        return application
+
+
+@FastApiBootstrapper.use_instrument()
+class FastApiPrometheusInstrument(PrometheusInstrument[FastApiPrometheusConfig]):
+    def bootstrap_after(self, application: ApplicationT) -> ApplicationT:
+        Instrumentator(**self.instrument_config.prometheus_instrumentator_params).instrument(
+            application,
+            **self.instrument_config.prometheus_instrument_params,
+        ).expose(
+            application,
+            endpoint=self.instrument_config.prometheus_metrics_path,
+            include_in_schema=self.instrument_config.prometheus_metrics_include_in_schema,
+            **self.instrument_config.prometheus_expose_params,
+        )
+        return application
+
+    @classmethod
+    def get_config_type(cls) -> type[FastApiPrometheusConfig]:
+        return FastApiPrometheusConfig
+
+
+@FastApiBootstrapper.use_instrument()
+class FastApiHealthChecksInstrument(HealthChecksInstrument):
+    def build_fastapi_health_check_router(self) -> fastapi.APIRouter:
+        fastapi_router: typing.Final = fastapi.APIRouter(
+            tags=["probes"],
+            include_in_schema=self.instrument_config.health_checks_include_in_schema,
+        )
+
+        @fastapi_router.get(self.instrument_config.health_checks_path)
+        async def health_check_handler() -> HealthCheckTypedDict:
+            return self.render_health_check_data()
+
+        return fastapi_router
+
+    def bootstrap_after(self, application: ApplicationT) -> ApplicationT:
+        application.include_router(self.build_fastapi_health_check_router())
+        return application

microbootstrap/bootstrappers/faststream.py

@@ -0,0 +1,121 @@
+from __future__ import annotations
+import json
+import typing
+
+import prometheus_client
+import structlog
+import typing_extensions
+from faststream.asgi import AsgiFastStream, AsgiResponse
+from faststream.asgi import get as handle_get
+
+from microbootstrap.bootstrappers.base import ApplicationBootstrapper
+from microbootstrap.config.faststream import FastStreamConfig
+from microbootstrap.instruments.health_checks_instrument import HealthChecksInstrument
+from microbootstrap.instruments.logging_instrument import LoggingInstrument
+from microbootstrap.instruments.opentelemetry_instrument import (
+    BaseOpentelemetryInstrument,
+    FastStreamOpentelemetryConfig,
+)
+from microbootstrap.instruments.prometheus_instrument import FastStreamPrometheusConfig, PrometheusInstrument
+from microbootstrap.instruments.pyroscope_instrument import PyroscopeInstrument
+from microbootstrap.instruments.sentry_instrument import SentryInstrument
+from microbootstrap.settings import FastStreamSettings
+
+
+class KwargsAsgiFastStream(AsgiFastStream):
+    def __init__(self, **kwargs: typing.Any) -> None:  # noqa: ANN401
+        # `broker` argument is positional-only
+        super().__init__(kwargs.pop("broker", None), **kwargs)
+
+
+class FastStreamBootstrapper(ApplicationBootstrapper[FastStreamSettings, AsgiFastStream, FastStreamConfig]):
+    application_config = FastStreamConfig()
+    application_type = KwargsAsgiFastStream
+
+    def bootstrap_before(self: typing_extensions.Self) -> dict[str, typing.Any]:
+        return {
+            "title": self.settings.service_name,
+            "version": self.settings.service_version,
+            "description": self.settings.service_description,
+            "on_shutdown": [self.teardown],
+            "on_startup": [self.console_writer.print_bootstrap_table],
+            "asyncapi_path": self.settings.asyncapi_path,
+        }
+
+
+FastStreamBootstrapper.use_instrument()(SentryInstrument)
+FastStreamBootstrapper.use_instrument()(PyroscopeInstrument)
+
+
+@FastStreamBootstrapper.use_instrument()
+class FastStreamOpentelemetryInstrument(BaseOpentelemetryInstrument[FastStreamOpentelemetryConfig]):
+    def is_ready(self) -> bool:
+        return bool(self.instrument_config.opentelemetry_middleware_cls and super().is_ready())
+
+    def bootstrap_after(self, application: AsgiFastStream) -> AsgiFastStream:  # type: ignore[override]
+        if self.instrument_config.opentelemetry_middleware_cls and application.broker:
+            application.broker.add_middleware(
+                self.instrument_config.opentelemetry_middleware_cls(tracer_provider=self.tracer_provider)
+            )
+        return application
+
+    @classmethod
+    def get_config_type(cls) -> type[FastStreamOpentelemetryConfig]:
+        return FastStreamOpentelemetryConfig
+
+
+@FastStreamBootstrapper.use_instrument()
+class FastStreamLoggingInstrument(LoggingInstrument):
+    def bootstrap_before(self) -> dict[str, typing.Any]:
+        return {"logger": structlog.get_logger("microbootstrap-faststream")}
+
+
+@FastStreamBootstrapper.use_instrument()
+class FastStreamPrometheusInstrument(PrometheusInstrument[FastStreamPrometheusConfig]):
+    def is_ready(self) -> bool:
+        return bool(self.instrument_config.prometheus_middleware_cls and super().is_ready())
+
+    def bootstrap_before(self) -> dict[str, typing.Any]:
+        return {
+            "asgi_routes": (
+                (
+                    self.instrument_config.prometheus_metrics_path,
+                    prometheus_client.make_asgi_app(prometheus_client.REGISTRY),
+                ),
+            )
+        }
+
+    def bootstrap_after(self, application: AsgiFastStream) -> AsgiFastStream:  # type: ignore[override]
+        if self.instrument_config.prometheus_middleware_cls and application.broker:
+            application.broker.add_middleware(
+                self.instrument_config.prometheus_middleware_cls(registry=prometheus_client.REGISTRY)
+            )
+        return application
+
+    @classmethod
+    def get_config_type(cls) -> type[FastStreamPrometheusConfig]:
+        return FastStreamPrometheusConfig
+
+
+@FastStreamBootstrapper.use_instrument()
+class FastStreamHealthChecksInstrument(HealthChecksInstrument):
+    def bootstrap(self) -> None: ...
+    def bootstrap_before(self) -> dict[str, typing.Any]:
+        @handle_get
+        async def check_health(scope: typing.Any) -> AsgiResponse:  # noqa: ANN401, ARG001
+            return (
+                AsgiResponse(
+                    json.dumps(self.render_health_check_data()).encode(), 200, headers={"content-type": "text/plain"}
+                )
+                if await self.define_health_status()
+                else AsgiResponse(b"Service is unhealthy", 500, headers={"content-type": "application/json"})
+            )
+
+        return {"asgi_routes": ((self.instrument_config.health_checks_path, check_health),)}
+
+    async def define_health_status(self) -> bool:
+        return await self.application.broker.ping(timeout=5) if self.application and self.application.broker else False
+
+    def bootstrap_after(self, application: AsgiFastStream) -> AsgiFastStream:  # type: ignore[override]
+        self.application = application
+        return application

microbootstrap/bootstrappers/litestar.py

@@ -0,0 +1,166 @@
+from __future__ import annotations
+import typing
+
+import litestar
+import litestar.exceptions
+import litestar.types
+import typing_extensions
+from litestar import openapi
+from litestar.config.cors import CORSConfig as LitestarCorsConfig
+from litestar.contrib.opentelemetry.config import OpenTelemetryConfig as LitestarOpentelemetryConfig
+from litestar.contrib.prometheus import PrometheusConfig, PrometheusController
+from litestar.openapi.plugins import SwaggerRenderPlugin
+from litestar_offline_docs import generate_static_files_config
+from sentry_sdk.integrations.litestar import LitestarIntegration
+
+from microbootstrap.bootstrappers.base import ApplicationBootstrapper
+from microbootstrap.config.litestar import LitestarConfig
+from microbootstrap.instruments.cors_instrument import CorsInstrument
+from microbootstrap.instruments.health_checks_instrument import HealthChecksInstrument, HealthCheckTypedDict
+from microbootstrap.instruments.logging_instrument import LoggingInstrument
+from microbootstrap.instruments.opentelemetry_instrument import OpentelemetryInstrument
+from microbootstrap.instruments.prometheus_instrument import LitestarPrometheusConfig, PrometheusInstrument
+from microbootstrap.instruments.pyroscope_instrument import PyroscopeInstrument
+from microbootstrap.instruments.sentry_instrument import SentryInstrument
+from microbootstrap.instruments.swagger_instrument import SwaggerInstrument
+from microbootstrap.middlewares.litestar import build_litestar_logging_middleware
+from microbootstrap.settings import LitestarSettings
+
+
+class LitestarBootstrapper(
+    ApplicationBootstrapper[LitestarSettings, litestar.Litestar, LitestarConfig],
+):
+    application_config = LitestarConfig()
+    application_type = litestar.Litestar
+
+    def bootstrap_before(self: typing_extensions.Self) -> dict[str, typing.Any]:
+        return {
+            "debug": self.settings.service_debug,
+            "on_shutdown": [self.teardown],
+            "on_startup": [self.console_writer.print_bootstrap_table],
+        }
+
+
+@LitestarBootstrapper.use_instrument()
+class LitestarSentryInstrument(SentryInstrument):
+    def bootstrap(self) -> None:
+        for sentry_integration in self.instrument_config.sentry_integrations:
+            if isinstance(sentry_integration, LitestarIntegration):
+                break
+        else:
+            self.instrument_config.sentry_integrations.append(LitestarIntegration())
+        super().bootstrap()
+
+
+@LitestarBootstrapper.use_instrument()
+class LitestarSwaggerInstrument(SwaggerInstrument):
+    def bootstrap_before(self) -> dict[str, typing.Any]:
+        render_plugins: typing.Final = (
+            (
+                SwaggerRenderPlugin(
+                    js_url=f"{self.instrument_config.service_static_path}/swagger-ui-bundle.js",
+                    css_url=f"{self.instrument_config.service_static_path}/swagger-ui.css",
+                    standalone_preset_js_url=(
+                        f"{self.instrument_config.service_static_path}/swagger-ui-standalone-preset.js"
+                    ),
+                ),
+            )
+            if self.instrument_config.swagger_offline_docs
+            else (SwaggerRenderPlugin(),)
+        )
+
+        all_swagger_params: typing.Final = {
+            "path": self.instrument_config.swagger_path,
+            "title": self.instrument_config.service_name,
+            "version": self.instrument_config.service_version,
+            "description": self.instrument_config.service_description,
+            "render_plugins": render_plugins,
+        } | self.instrument_config.swagger_extra_params
+
+        bootstrap_result: typing.Final[dict[str, typing.Any]] = {
+            "openapi_config": openapi.OpenAPIConfig(**all_swagger_params),
+        }
+        if self.instrument_config.swagger_offline_docs:
+            bootstrap_result["static_files_config"] = [
+                generate_static_files_config(static_files_handler_path=self.instrument_config.service_static_path),
+            ]
+        return bootstrap_result
+
+
+@LitestarBootstrapper.use_instrument()
+class LitestarCorsInstrument(CorsInstrument):
+    def bootstrap_before(self) -> dict[str, typing.Any]:
+        return {
+            "cors_config": LitestarCorsConfig(
+                allow_origins=self.instrument_config.cors_allowed_origins,
+                allow_methods=self.instrument_config.cors_allowed_methods,  # type: ignore[arg-type]
+                allow_headers=self.instrument_config.cors_allowed_headers,
+                allow_credentials=self.instrument_config.cors_allowed_credentials,
+                allow_origin_regex=self.instrument_config.cors_allowed_origin_regex,
+                expose_headers=self.instrument_config.cors_exposed_headers,
+                max_age=self.instrument_config.cors_max_age,
+            ),
+        }
+
+
+LitestarBootstrapper.use_instrument()(PyroscopeInstrument)
+
+
+@LitestarBootstrapper.use_instrument()
+class LitestarOpentelemetryInstrument(OpentelemetryInstrument):
+    def bootstrap_before(self) -> dict[str, typing.Any]:
+        return {
+            "middleware": [
+                LitestarOpentelemetryConfig(
+                    tracer_provider=self.tracer_provider,
+                    exclude=self.define_exclude_urls(),
+                ).middleware,
+            ],
+        }
+
+
+@LitestarBootstrapper.use_instrument()
+class LitestarLoggingInstrument(LoggingInstrument):
+    def bootstrap_before(self) -> dict[str, typing.Any]:
+        if self.instrument_config.logging_turn_off_middleware:
+            return {}
+
+        return {"middleware": [build_litestar_logging_middleware(self.instrument_config.logging_exclude_endpoints)]}
+
+
+@LitestarBootstrapper.use_instrument()
+class LitestarPrometheusInstrument(PrometheusInstrument[LitestarPrometheusConfig]):
+    def bootstrap_before(self) -> dict[str, typing.Any]:
+        class LitestarPrometheusController(PrometheusController):
+            path = self.instrument_config.prometheus_metrics_path
+            include_in_schema = self.instrument_config.prometheus_metrics_include_in_schema
+            openmetrics_format = True
+
+        litestar_prometheus_config: typing.Final = PrometheusConfig(
+            app_name=self.instrument_config.service_name,
+            **self.instrument_config.prometheus_additional_params,
+        )
+
+        return {"route_handlers": [LitestarPrometheusController], "middleware": [litestar_prometheus_config.middleware]}
+
+    @classmethod
+    def get_config_type(cls) -> type[LitestarPrometheusConfig]:
+        return LitestarPrometheusConfig
+
+
+@LitestarBootstrapper.use_instrument()
+class LitestarHealthChecksInstrument(HealthChecksInstrument):
+    def build_litestar_health_check_router(self) -> litestar.Router:
+        @litestar.get(media_type=litestar.MediaType.JSON)
+        async def health_check_handler() -> HealthCheckTypedDict:
+            return self.render_health_check_data()
+
+        return litestar.Router(
+            path=self.instrument_config.health_checks_path,
+            route_handlers=[health_check_handler],
+            tags=["probes"],
+            include_in_schema=self.instrument_config.health_checks_include_in_schema,
+        )
+
+    def bootstrap_before(self) -> dict[str, typing.Any]:
+        return {"route_handlers": [self.build_litestar_health_check_router()]}

microbootstrap/config/fastapi.py

@@ -0,0 +1,64 @@
+from __future__ import annotations
+import dataclasses
+import typing
+
+from fastapi.datastructures import Default
+from fastapi.utils import generate_unique_id
+from starlette.responses import JSONResponse
+
+
+if typing.TYPE_CHECKING:
+    from fastapi import Request, routing
+    from fastapi.applications import AppType
+    from fastapi.middleware import Middleware
+    from fastapi.params import Depends
+    from starlette.responses import Response
+    from starlette.routing import BaseRoute
+    from starlette.types import Lifespan
+
+
+@dataclasses.dataclass
+class FastApiConfig:
+    debug: bool = False
+    routes: list[BaseRoute] | None = None
+    title: str = "FastAPI"
+    summary: str | None = None
+    description: str = ""
+    version: str = "0.1.0"
+    openapi_url: str | None = "/openapi.json"
+    openapi_tags: list[dict[str, typing.Any]] | None = None
+    servers: list[dict[str, str | typing.Any]] | None = None
+    dependencies: typing.Sequence[Depends] | None = None
+    default_response_class: type[Response] = dataclasses.field(default_factory=lambda: Default(JSONResponse))
+    redirect_slashes: bool = True
+    docs_url: str | None = "/docs"
+    redoc_url: str | None = "/redoc"
+    swagger_ui_oauth2_redirect_url: str | None = "/docs/oauth2-redirect"
+    swagger_ui_init_oauth: dict[str, typing.Any] | None = None
+    middleware: typing.Sequence[Middleware] | None = None
+    exception_handlers: (
+        dict[
+            int | type[Exception],
+            typing.Callable[[Request, typing.Any], typing.Coroutine[typing.Any, typing.Any, Response]],
+        ]
+        | None
+    ) = None
+    on_startup: typing.Sequence[typing.Callable[[], typing.Any]] | None = None
+    on_shutdown: typing.Sequence[typing.Callable[[], typing.Any]] | None = None
+    lifespan: Lifespan[AppType] | None = None  # type: ignore[valid-type]
+    terms_of_service: str | None = None
+    contact: dict[str, str | typing.Any] | None = None
+    license_info: dict[str, str | typing.Any] | None = None
+    openapi_prefix: str = ""
+    root_path: str = ""
+    root_path_in_servers: bool = True
+    responses: dict[int | str, dict[str, typing.Any]] | None = None
+    callbacks: list[BaseRoute] | None = None
+    webhooks: routing.APIRouter | None = None
+    deprecated: bool | None = None
+    include_in_schema: bool = True
+    swagger_ui_parameters: dict[str, typing.Any] | None = None
+    generate_unique_id_function: typing.Callable[[routing.APIRoute], str] = dataclasses.field(
+        default_factory=lambda: Default(generate_unique_id),
+    )
+    separate_input_output_schemas: bool = True