Use Request instead of Pydantic model in POST, but still document the pydanti model

[achempak-polymer]

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 fastapi import FastAPI, Request
from pydantic import BaseModel

app = FastAPI()

class Foo(BaseModel):
  bar: str

@app.post("/test")
async def test(req: Request):
  body = await req.body().decode("utf-8")
  # do stuff with body
  parsed = Foo.model_validate_json(body)
  # do stuff with parsed

Description

Is there a way to still document Foo as the request body for /test while still using Request instead of Foo as the input for test()? The reason we want to do this is that we're getting ClientDisconnect errors while the request is being validated and parsed into the pydantic model if we use it as a parameter for test(), before the logic inside test() even has a chance to execute. The only way to catch these errors is to manually parse the raw Request object. Without this, we get nebulous ASGI exception errors in our logs that aren't very useful, and make it hard to distinguish more critical ASGI errors that might be due to memory leaks, for example.

Operating System

Linux, macOS

Operating System Details

No response

FastAPI Version

0.109.1

Pydantic Version

2.3.0

Python Version

3.11

Additional Context

No response

[n8sty]

I'm not aware of a way to achieve exactly what you're asking but you may want to try to switch Foo to be a dataclass instead of a Pydantic model since the former does significantly less validation.

[YuriiMotov]

You can declare every path operation twice, but disable including in openapi schema for one of them. Only first operation will be executed

from fastapi import FastAPI, Request
from pydantic import BaseModel

app = FastAPI()


class Item(BaseModel):
    name: str


# This operation will NOT be included in openapi schema, but it will be executed
@app.post("/", include_in_schema=False)
async def route_real(request: Request):
    print("real")
    body = (await request.body()).decode("utf-8")
    parsed = Item.model_validate_json(body)
    print(parsed.model_dump())

# This operation will be included in openapi schema, but it will NOT be executed
@app.post("/")
def route_fake(item: Item):
    raise NotImplementedError()

If you perform a post request to "/" it will print "real" in console, but in the documentation you will see documentation for route_fake endpoint. You can rename function names as you want. You can even use the same name for both of them.

But I'm not sure if this is a good approach. I assume that this behavior may be changed in the future..

[sehraramiz]

one way to solve your problem is to define openapi specs separately with custom openapi schema on routers.

from fastapi import FastAPI, Request
from pydantic import BaseModel

app = FastAPI()


class Foo(BaseModel):
    bar: str


@app.post(
    "/test",
    openapi_extra={
        "requestBody": {
            "content": {
                "application/json": {
                    "schema": Foo.schema()
                }
            },
            "required": True,
        },
    },
)
async def test(req: Request):
    body = await req.body()
    body = body.decode("utf-8")
    parsed = Foo.model_validate_json(body)

[achempak-polymer]

Thanks both of you guys! These both work - I ended up going with @YuriiMotov 's approach since that one guarantees the schema will be the exact same as what I had before.