Request parameters model not exported to docs (and OpenAPI Specification)

[Philipp3211]

First Check

• I added a very descriptive title here.
• I used the GitHub search to find a similar question and didn't find it.
• I searched the FastAPI documentation, with the integrated search.
• I already searched in Google "How to X in FastAPI" and didn't find any information.
• I already read and followed all the tutorial in the docs and didn't find an answer.
• I already checked if it is not related to FastAPI but to Pydantic.
• I already checked if it is not related to FastAPI but to Swagger UI.
• I already checked if it is not related to FastAPI but to ReDoc.

Commit to Help

• I commit to help with one of those options 👆

Example Code

from typing import Annotated

from fastapi import FastAPI, Depends
from pydantic import BaseModel


class ParamsModel(BaseModel):
    foo: str
    bar: str


app = FastAPI()


@app.get("/")
def test_route(params: Annotated[ParamsModel, Depends()]):
    return params.foo + params.bar

Description

Start the app then open the browser and go to /docs and /openapi.json respectively

What is currently:

• /docs: ParamsModel is not present in the Schemas. Right now only HTTPValidationError and ValidationError are in the schemas.
• /openapi.json: ParamsModel is not present in the OpenAPI-Spec either

What I'm expecting:

• I want the ParamsModel to be present in the schemas and the OpenAPI-Spec

Why do I need this?
The type is required for my UI being able to handle the request data by using OpenAPI exported types only.

I need foo and bar as parameters because on UI side I use caching that depends on foo and bar being present in the URL.

Is there a way to get this behavior with FastAPI?

Operating System

Linux, Windows

Operating System Details

No response

FastAPI Version

0.110.2

Pydantic Version

1.10.2

Python Version

Python 3.9.5

Additional Context

No response

[PhysicallyActive]

Why do you need the use of Depends? Shouldn't this solve your issue

from fastapi import FastAPI
from pydantic import BaseModel


class ParamsModel(BaseModel):
    foo: str
    bar: str


app = FastAPI()


@app.post("/")
def test_route(params: ParamsModel):
    return params.foo + params.bar

[Philipp3211]

You are right, pydantic models are not supported. However even after switching to usual class or dataclass, the model still isn't exported to the schemas or openapi specification.

[YuriiMotov]

from dataclasses import dataclass
from typing import Annotated

from fastapi import Depends, FastAPI


@dataclass
class ParamsModel:
    foo: str
    bar: str


app = FastAPI()


@app.get("/")
def test_route(params: Annotated[ParamsModel, Depends()]):
    return params.foo + params.bar

In the Swagger docs it looks as follows:

Is it what you need? Or do you expect something else?

[Philipp3211]

To quote from my question above:

What is currently:
/docs: ParamsModel is not present in the Schemas. Right now only HTTPValidationError and ValidationError are in the schemas.
/openapi.json: ParamsModel is not present in the OpenAPI-Spec either

What I'm expecting:
I want the ParamsModel to be present in the schemas and the OpenAPI-Spec

[YuriiMotov]

Oh, now I see.. Sorry for the inattention.

I don't think you can easily do what you want in current version of FastAPI since it only accepts simple types (and arrays of simple type parameters) as a Query parameters.

When you use annotation like
params: Annotated[ParamsModel, Depends()]
it is just a shortcut to
params: Annotated[ParamsModel, Depends(ParamsModel)]

FastAPI just looks at the parameters of ParamsModel's init method and treats them as subdependencies. So, it's equivalent of

def get_query_params_dep(foo: str, bar: str) -> ParamsModel:
    return ParamsModel(foo=foo, bar=bar)

@app.get("/")
def test_route(params: Annotated[ParamsModel, Depends(get_query_params_dep)]):
    return params.foo + params.bar

I think you can (?) only achieve what you want by modifying openapi schema. Take a look at this:

from dataclasses import dataclass
from typing import Annotated

from fastapi import Depends, FastAPI
from fastapi.openapi.utils import get_openapi
from pydantic import TypeAdapter

app = FastAPI()

@dataclass
class ParamsModel:
    foo: str
    bar: str

@app.get("/")
def test_route(params: Annotated[ParamsModel, Depends()]):
    return params.foo + params.bar


def custom_openapi():
    if app.openapi_schema:
        return app.openapi_schema
    openapi_schema = get_openapi(
        title=app.title,
        version=app.version,
        routes=app.routes
    )
    openapi_schema["components"]["schemas"]["ParamsModel"] = TypeAdapter(ParamsModel).json_schema()
    
    path_params = openapi_schema["paths"]["/"]["get"]["parameters"]
    EXCLUDE_PARAMS = ("foo", "bar")
    path_params = [param for param in path_params if param["name"] not in EXCLUDE_PARAMS]
    path_params.append(
        {
            "name": "params",
            "in": "query",
            "schema": {"type": "object", "ref": "#/components/schemas/ParamsModel"},
            "style": "form",
            "explode": True
        }
    )
    openapi_schema["paths"]["/"]["get"]["parameters"] = path_params
    
    app.openapi_schema = openapi_schema
    return app.openapi_schema

app.openapi = custom_openapi

This produces the following schema for path:

"/": {
    "get": {
        "summary": "Test Route",
        "operationId": "test_route__get",
        "parameters": [
            {
                "name": "params",
                "in": "query",
                "schema": {
                    "type": "object",
                    "ref": "#/components/schemas/ParamsModel"
                },
                "style": "form",
                "explode": true
            }
        ],
...

But pay attention, that FastAPI docs doesn't declare supporting dataclasses as Query parameters. It works for simple cases, but you may have troubles in more complex cases.

[Philipp3211]

Yes, you can use either usual classes or dataclasses, but not Pydantic models for Query parameters.

Where did you read that dataclasses are allowed for query parameters? I can't find any info on this.

[YuriiMotov]

I didn't find anything in the documentation about supporting dataclasses as Query parameters, but at least in simple cases it works.
Dataclasses are useful here, because they create init method automatically, so you don't need to write it manually.

[Philipp3211]

Well pydantic models also work for me, but they are explicitly not supported as stated in the link from you #9709 (reply in thread)

I'm gonna stick with the documentation and use a casual class. If you want you can edit your answer and I will accept it as an answer.

[Philipp3211]

Forget what I just wrote. The solution doesn't work without the @dataclass decorator. If I remove it, I get Unable to generate pydantic-core schema.