Regarding the form issue, how to rebuild the form and pass it to the interface endpoint after consuming the stream?

[YaoJusheng]

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

class CaptureFormMiddleware(BaseHTTPMiddleware):
    async def dispatch(self, request: Request, call_next):
        if request.method == "POST" and request.headers.get("content-type", "").startswith("multipart/form-data"):

            form = await request.form()
            request.state.form = form
            ... # do something like: `content = await file.read()`
        
        response = await call_next(request)
        return response

app.add_middleware(CaptureFormMiddleware)


@app.post("/upload/")
async def upload_file(request: Request, file: UploadFile = File(...)):
    saved_file = request.state.file
    content = await file.read()
    return {
        "filename": file.filename,
        "content": content.decode(),
    }

Description

After each request to upload a file, the interface endpoint always reports an error: 422 Unprocessable Entity, which is caused by the stream being consumed.

So how should I rebuild the formdata in CaptureFormMiddleware to meet the parameter requirements of the endpoint?

Operating System

macOS

Operating System Details

No response

FastAPI Version

0.115.0

Pydantic Version

2.9.2

Python Version

3.10.12

Additional Context

No response

[Kfir-G]

@YaoJusheng
The issue happens because the file stream gets consumed in the middleware, so by the time the request reaches the endpoint, it's already been "used up." To fix this, you need to capture the form data (including the file) in the middleware, save it, and then pass it along so the endpoint can use it.

Here's a solution:

1. In the middleware, read the file and store its content in request.state.
2. In the endpoint, pull the file content from request.state instead of reading it again.

Example:

class CaptureFormMiddleware(BaseHTTPMiddleware):
    async def dispatch(self, request: Request, call_next):
        if request.method == "POST" and request.headers.get("content-type", "").startswith("multipart/form-data"):
            form = await request.form()
            request.state.form = form
            form_files = {}
            for key, file in form.items():
                if isinstance(file, UploadFile):
                    form_files[key] = await file.read()  # Save file content
            request.state.form_files = form_files
        
        response = await call_next(request)
        return response

@app.post("/upload/")
async def upload_file(request: Request, file: UploadFile = File(...)):
    saved_file_content = request.state.form_files.get("file")
    return {
        "filename": file.filename,
        "content": saved_file_content.decode(),  # Use cached file content
    }

Basically, the file gets read once in the middleware and stored, so you can use it later without running into the stream consumption issue that caused the 422 error.

[YaoJusheng]

Thank you very much for your reply!

I know the method of request.state. My purpose is to capture the form including the file stream in the middleware and do some integrity-related verification. After passing it, it will be given to the handler of the specific endpoint.

However, I want to use the corresponding interface which the stream is still obtained through UploadFile instead of request.state, so I mentioned in the description whether this scenario can be achieved by rebuilding the request after consuming the stream.

I didn't see any related cases, but I finally achieved the goal by assigning a value to request._body in the middleware. I'm not sure if there is a more elegant way to achieve it.