FastAPI - Application Hangs upon combining pydantic.Model and fastapi.router

[msSarriman]

Given a FastAPI application, with pydantic models at the URIs input parameters, there are two different behaviors that are being observed, depending on if the request's body is read or not in @app.middleware("http").

Given a simple application:

#!/Users/esarris/miniconda3/bin/python
import fastapi
import uvicorn
import time
import json
import uuid
import pydantic
from json.decoder import JSONDecodeError
from fastapi.middleware.cors import CORSMiddleware


app = fastapi.FastAPI()


async def _log_request(request: fastapi.Request):
    body_type = "Empty"
    try:
        request_body = await request.json()
        body_type = "json"
    except JSONDecodeError as e:
        try:
            request_body = await request.body()
            body_type = "body"
        except Exception as e:
            request_body = "Not Parsable"
    request_body = json.dumps(request_body) if body_type == "json" else request_body.decode("utf-8")
    print(request_body)


class ReqModelWithReq(pydantic.BaseModel, fastapi.Request):
    buyer: str


class ReqModelNoReq(pydantic.BaseModel):
    buyer: str


router1 = fastapi.APIRouter(prefix="/routerWithReq")


@router1.post("/")
def root_router(req: ReqModelWithReq):
    print("router1 root " + req.buyer)
    response = fastapi.responses.RedirectResponse("/routerPost")
    return response


@router1.post("/routerPost")
def routerPost_post(req: ReqModelWithReq):
    print("router1 routerPost " + req.buyer)
    return "routerPost reached"


router2 = fastapi.APIRouter(prefix="/routerNoReq")


@router2.post("/")
def root_router2(req: ReqModelNoReq):
    print("router2 root " + req.buyer)
    response = fastapi.responses.RedirectResponse("/routerPost")
    return response


@router2.post("/routerPost")
def routerPost_post2(req: ReqModelNoReq):
    print("router2 routerPost " + req.buyer)
    return "routerPost2 reached"


app.include_router(router1)
app.include_router(router2)


@app.middleware("http")
async def log_reqeusts(request: fastapi.Request, call_next):
    await _log_request(request)
    response = await call_next(request)
    return response


@app.post("/noRouter/postTestWithRequest")
async def test_post(req: ReqModelWithReq = fastapi.Body(None, embed=False)):
    print("no router - with request " + req.buyer)
    return "noRouter test withRequest reached"


@app.post("/noRouter/postTestNoRequest")
async def test_post(req: ReqModelNoReq = fastapi.Body(None, embed=False)):
    print("no router - without request " + req.buyer)
    return "noRouter test with NO Request reached"


def main():
    uvicorn.run(
        "main:app",
        host="0.0.0.0",
        port=8080
    )


if __name__ == "__main__":
    main()

After executing the above script, and bringing up the server, the following behaviors are being observed:

URI	POST /routerWithReq/	POST /routerWithReq/routerPost	POST /routerNoReq/	POST /routerNoReq/routerPost	POST /noRouter/postTestWithRequest	POST /noRouter/postTestNoRequest
CURL	curl --location --request POST 'http://localhost:8080/routerWithReq'\ --header 'Content-Type: application/json' \ --data-raw '{ "buyer": "foo" }'`	curl --location --request POST 'http://localhost:8080/routerWithReq/routerPost'\ --header 'Content-Type: application/json' \ --data-raw '{ "buyer": "foo" }'	curl --location --request POST 'http://localhost:8080/routerNoReq'\ --header 'Content-Type: application/json' \ --data-raw '{ "buyer": "foo" }'	curl --location --request POST 'http://localhost:8080/routerNoReq/routerPost'\ --header 'Content-Type: application/json' \ --data-raw '{ "buyer": "foo" }'	curl --location --request POST 'http://localhost:8080/noRouter/postTestWithRequest'\ --header 'Content-Type: application/json' \ --data-raw '{ "buyer": "foo" }'	curl --location --request POST 'http://localhost:8080/noRouter/postTestNoRequest'\ --header 'Content-Type: application/json' \ --data-raw '{ "buyer": "foo" }'
Results when: Middleware Logs Body	AttributeError: 'Request' object has no attribute 'buyer'	AttributeError: 'Request' object has no attribute 'buyer'	Application Runtime HANGS	Application Runtime HANGS	AttributeError: 'Request' object has no attribute 'buyer'	Application Runtime HANGS
Results when: Middleware NOT Logging Body	AttributeError: 'Request' object has no attribute 'buyer'	AttributeError: 'Request' object has no attribute 'buyer'	INFO: 127.0.0.1:57182 - "POST /routerNoReq HTTP/1.1" 307 Temporary Redirect router2 rootfoo INFO: 127.0.0.1:57182 - "POST /routerNoReq/ HTTP/1.1" 307 Temporary Redirect INFO: 127.0.0.1:57182 - "POST /routerPost HTTP/1.1" 404 Not Found	router2 routerPost foo INFO: 127.0.0.1:57758 - "POST /routerNoReq/routerPost HTTP/1.1" 200 OK	AttributeError: 'Request' object has no attribute 'buyer'	no router - without request foo INFO: 127.0.0.1:57832 - "POST /noRouter/postTestNoRequest HTTP/1.1" 200 OK

The above table, indicates that when the pydantic.Model is being used to define the input parameter model, then the application Hangs when the Model is not an extension of the fastapi.requests.Request and the @app.middleware is logging the body.
On the other hand, when there @app.middleware is not logging the body, then the application works fine, and without having the need to extend the Model to inherit from the fastpi.requests.Request.

Resolution:
a. Based on the above, is that when the @app.middleware is in place and attempts to log the body, then the fastapi.responses.RedirectResponse fails to redirect, and the request/application hangs. Extending the parameters to inherit from fastapi.responses.Reqeust makes the redirection take place, but then the input loses its Model attributes, and results to runtime errors.
b. It is very weird though, that when the @app.middleware is in place and DOESN'T log the body, then the application works fine, without the need to even make the Models inherit from fastapi.requests.Request.

Is the above a bug (Resolution-> a) on Starlette's fastapi.responses.RedirectResponse?
How it be that the behavior of the application changes so drastically upon logging the request body on the @app.middleware("http")?

If the above is not a bug, is it possible to utilize the router, with model, and redirect correctly to sub-resources?

[odiseo0]

This is the first time I've seen someone does that.

I don't think it's good and it seens FastAPI/Starlette doesn't like it either

[acidjunk]

Printing pydantic models evaluates them. When that evaluation has a problem -> crash.

To debug that kind of stuff make sure you aren't using the compiled pydantic: e.g. check the output of:

python -c "import pydantic.utils; print(pydantic.utils.version_info())"