Fastapi OpenAPI generation

[Tomtommytomtom]

When using dishka with the fastapi integration, i lose some of fastapis automatic openapi docs generation. Such as fastapi.Header and fastapi.Query. I can still access these through the Fastapi Provider and fastapi.Request but wiring these will not automatically generate docs for them.

Do you have any idea or suggestions how to use dishka and fastapi together without losing that?

[Tishka17]

Please, provide more details on your UseCase. You can combine Depends and FromDishka in one app. Use Depends for parsing parts of request and dishka only do providing dependencies (not data retrieved from request, but just objects containing logic/config parts)

[Tomtommytomtom]

The reason i am looking for an alternative to fastapi DI is because its unusable outside of their Requests.

I would like to reuse services in rest context and cli context:

from contextlib import asynccontextmanager
from dataclasses import dataclass
import sys
from typing import Annotated

from dishka import FromDishka, Provider, Scope, make_async_container, make_container, provide, from_context
from dishka.integrations.fastapi import DishkaRoute, FastapiProvider, setup_dishka
from fastapi import APIRouter, Depends, FastAPI, Query, Request

@dataclass(frozen=True)
class Tenant:
    name: str

# Use case, usable in both REST and CLI
class GetPriceUseCase:
    def __init__(self, tenant: Tenant):
        self.tenant = tenant

    def execute(self) -> float:
        if self.tenant.name == "tenant_a":
            return 100.0
        else:
            return 200.0

# Provider for REST requests
class TenantProviderRest(Provider):
    # No OpenAPI docs generated for routes where dependency chain leads to this factory
    @provide(scope=Scope.REQUEST)
    def get_tenant(self, request: Request) -> Tenant:
        return Tenant(name=request.query_params.get("tenant") or "")

# Provider for CLI runs
class TenantProviderCli(Provider):
    from_context = from_context(Tenant, scope=Scope.REQUEST)


usecase_provider = Provider(scope=Scope.REQUEST)
usecase_provider.provide_all(GetPriceUseCase)

fastapi_container = make_async_container(
    FastapiProvider(),
    TenantProviderRest(),
    usecase_provider,
)

cli_container = make_container(
    TenantProviderCli(),
    usecase_provider,
)

@asynccontextmanager
async def lifespan(app: FastAPI):
    root = app.state.dishka_container
    yield
    await root.close()


app = FastAPI(lifespan=lifespan, route_class=DishkaRoute)

setup_dishka(container=fastapi_container, app=app)

api_router = APIRouter(route_class=DishkaRoute)

@api_router.get("/dishka")
async def get_price(get_price_use_case: FromDishka[GetPriceUseCase]) -> float:
    return get_price_use_case.execute()


# fastapi.Quey correctly adds parameters field to OpenAPI docs
def get_tenant_from_header(tenant: Annotated[str, Query()]) -> Tenant:
    return Tenant(name=tenant.name)


def get_price_use_case_for_fastapi(
    tenant: Annotated[Tenant, Depends(get_tenant_from_header)],
) -> GetPriceUseCase:
    return GetPriceUseCase(tenant)


@api_router.get("/fastapi")
async def get_price_fastapi(
    use_case: Annotated[GetPriceUseCase, Depends(get_price_use_case_for_fastapi)],
) -> float:
    return use_case.execute()


app.include_router(api_router)

if __name__ == "__main__":
    args = sys.argv[1:]
    with cli_container({ Tenant: Tenant(name=args[0]) }) as request_container:
        print(request_container.get(GetPriceUseCase).execute())

the dishka route does not include tenant param in docs, /fastapi does include tenant parameter

"/dishka": {
      "get": {
        "summary": "Get Price",
        "operationId": "get_price_dishka_get",
        "responses": {
          "200": {
            "description": "Successful Response",
            "content": {
              "application/json": {
                "schema": {
                  "type": "number",
                  "title": "Response Get Price Dishka Get"
                }
              }
            }
          }
        }
      }
    },
    "/fastapi": {
      "get": {
        "summary": "Get Price Fastapi",
        "operationId": "get_price_fastapi_fastapi_get",
        "parameters": [
          {
            "name": "tenant",
            "in": "query",
            "required": true,
            "schema": {
              "type": "string",
              "title": "Tenant"
            }
          }
        ],
        ...

So my question is, can i somehow get openapi docs with dishka dependencies?

[Tishka17]

Looks like you do not need to pass tenant to object constructor (init param), but instead pass it as an argument to execute method.