"Value error, Expected UploadFile, received: <class 'str'>"

[markodjordjic]

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, File, UploadFile

app = FastAPI()


@app.post("/upload_file/")
async def create_upload_file(file: UploadFile):
    
    return {"filename": file.filename}

def test_upload_file:

        with tempfile.SpooledTemporaryFile(mode='wb') as fp:
            fp.write(b'Hello World!')
            fp.seek(0)

        upload_file = UploadFile(file=fp, filename='test_file.txt')

        data = {
            "file": upload_file
        }
        
        response = app.post("/upload_file/", data=data)

        actual = response.json()
    
        self.assertEqual(actual, expected)

Description

• Instead of reading the file, error in the title is thrown

Operating System

Windows

Operating System Details

Windows 11 Pro

FastAPI Version

0.111.0

Pydantic Version

2.7.1

Python Version

3.11.0

Additional Context

No response

[YuriiMotov]

Hi!
Why don't you use TestClient to test your endpoint?

import tempfile

from fastapi import FastAPI, UploadFile
from fastapi.testclient import TestClient

app = FastAPI()


@app.post("/upload_file/")
async def create_upload_file(file: UploadFile):
    return {"filename": file.filename}


client = TestClient(app)

def test_upload_file():
    file_name = 'test_file.txt'
    expected = {"filename": file_name}
    with tempfile.SpooledTemporaryFile(mode='wb+') as fp:
        fp.write(b'Hello World!')
        fp.seek(0)
        files = {'file': (file_name, fp)}
        response = client.post("/upload_file/", files=files)
        print(response.status_code)

    actual = response.json()

    assert actual == expected
    # self.assertEqual(actual, expected)

[YuriiMotov]

My example shows a common way of testing FastAPI applications: using TestClient to imitate HTTP-request to your application.

response = client.post("/upload_file/", files=files)

Instead of

response = app.post("/upload_file/", data=data) # This is wrong!

In your code app.post("/upload_file/", data=data) is not correct code, because app.post() is actually a decorator that you should use to decorate the endpoint functions and it doesn't have data parameter.

As I said, you should use TestClient to imitate request to your app. In this case UploadFile object will be created automatically from the dict that you are passing as a file parameter. So, your endpoint function will be called with right parameters.

I think it's also possible to test the endpoint by just calling it and passing right parameters, but in this case you can't override dependencies (that is very useful feature for testing).
I don't recommend this way:

upload_file = UploadFile(...)
res = create_upload_file(file=upload_file)
assert res == expected_res

[markodjordjic]

@YuriiMotov I dont understand why are you debating with me FastAPI testing? We are deviating from a larger issue, of a potential bug in the FastAPI. I already confirmed that your example is correct, and provided the explanation that my code is clumsy because it was extracted from I larger project. For the sake of clearer explanation, here is a part of the class that does the testing:

import unittest
from fastapi.testclient import TestClient
from app.handling_errors import app


class TestExercise(unittest.TestCase):

    def __init__(self, methodName: str = "runTest") -> None:
        super().__init__(methodName)
 
    @classmethod
    def setUp(self) -> None:
        self.app = TestClient(app=app)

In summary, I am using TestClient.

[YuriiMotov]

I can confirm that the proposal you suggested is working. But that is a workaround without using the UploadFile class.

You said that code I proposed you is a workaround. I just wanted to show you that it's not a workaround, and explained how it works.

Can you show a code example that demonstrates FastAPI bug you are talking about?

Please check your code before posting so that there are no syntactic and logical errors in it. Because the code you posted in the initial question contains lots of errors.

[markodjordjic]

@YuriiMotov You are obviously here from wrong reasons. I have provided the all the information about potential bug, as well as why I think your proposal (not the code) is a workaround, and confirmed (already two times) that your code is correct. Its all there if you want to read.

[YuriiMotov]

Calm down, please. I'm here to help people solve their problems with FastAPI. And to learn FastAPI in depth as well.

I have provided the all the information about potential bug

It may seem obvious to you what the bug is, but it's not clear to me.
The code you provided contains lots of errors. I can't run it and see the error message, that you mentioned in the title.

I also can see that you uses FastAPI object to perform a request instead of using TestClient (app variable is a global variable, that is an instance of FastAPI class. If you want to use TestClient object, you should change it to self.app).

If you want to understand, whether there is a bug in FastAPI related to UploadFile or not, please clarify your question and provide code example that we can run.

[PREPONDERANCE]

@markodjordjic I don't think the way you initialize the UploadFile is incorrect but the way you're testing it since app does not have a parameter called data and is only used for defining API endpoints.

[markodjordjic]

@PREPONDERANCE Many thanks. Can you propose a different way for the endpoint to receive the UploadFile class to the endpoint? I'm all ears :)

[PREPONDERANCE]

As in my experience, I'm using Annotated along with File metadata provided by FastAPI to enable file uploading. The example code will demonstrate my idea.

from fastapi import File, UploadFile, APIRouter

router = APIRouter()

@router.post("/path/to/your/endpoint")
def example_code(file: Annotated[UploadFile, File]):
    pass

To test whether it works, one way I prefer will be accessing the openAPI docs 127.0.0.1:8000/docs (port number may differ). Find your endpoint definition and hit try. You'll see the corresponding endpoint being called in the terminal.

Another way I'd like to test this is by using tools such as postman (in VsCode, there's a plugin called ThunderClient which is very helpful as well). Turn on your local backend and call the endpoint with correct data format passed in.

[markodjordjic]

@PREPONDERANCE Thanks for proposal. So far the same error is being thrown (Value error, Expected UploadFile, received: <class \'str\'>) I'll keep working on it, and make a final conclusion. It seems that there is more and more evidence that there is some kind of bug. Simply put, even if the class UploadFile is correctly instantiated in the test, it cannot be consumed by the endpoint, regardless how the arguments are defined. I'll make further investigation, and in case you can think of something else feel free to post.

[JavierSanchezCastro]

Add a MRE: https://stackoverflow.com/help/minimal-reproducible-example

[JavierSanchezCastro]

As I know, no

[markodjordjic]

@JavierSanchezCastro I'll do further testing. But if that is the case, it defeats the purpose of UploadFile class. What is the point of introducing a class, then declaring it as input data-type of a function argument, and then sending a dict with a tuple? Complete FastAPI relies on annotation of data-types, and this definitely is a deviation from that design philosophy.

[markodjordjic]

@JavierSanchezCastro But it still is worth considering is this behavior (throwing an error) as expected? Maybe it is bug? I'll see if I can forward this to someone to clarify. @JavierSanchezCastro many thanks for the help!

[JavierSanchezCastro]

Check this one: #7470 (comment)

Also, you have this example using UploadFile: #7470 (comment)

And this comment: #7470 (comment)

Hope it helps!

[markodjordjic]

@JavierSanchezCastro thanks for the examples. They all point in the same direction. Declaring a function argument as 'UploadFile' data-type is not necessary (or can throw an error), since an instance of UploadFile class cannot be sent. The only other purpose this can serve is maybe to make a distinction from other usages of dict, when a file_like object is expected. But I guess there are better ways to annotate this. Strictly speaking function should receive only arguments of the same data-type declared in the definition of the function.