Originally published on Medium under the Python in Plain English publication.

In the world of FastAPI, file uploads are a common requirement for many applications. The UploadFile class serves as a key component for handling file uploads efficiently. However, a common point of confusion arises when developers check the type of an UploadFile instance, only to find that it appears to be an instance of Starlette’s UploadFile instead of FastAPI’s. In this blog, we will dive deep into the architecture of FastAPI, examine the nature of the UploadFile class, and clarify why this behavior occurs.

The Architecture Behind FastAPI

FastAPI is built on top of Starlette, which is a lightweight ASGI framework. This design choice allows FastAPI to leverage the high-performance capabilities of Starlette while extending it with additional features like automatic data validation and serialization through Pydantic. One of the main components of FastAPI for handling file uploads is the UploadFile class, which is designed for easy interaction with files uploaded through HTTP requests.

When you import UploadFile in your FastAPI application, you are actually importing a subclass of Starlette’s UploadFile. The FastAPI implementation adds some extra functionality and enhancements, but it fundamentally relies on the core mechanics provided by Starlette.

The Confusion: Type Checking

Consider the following code snippet where we check the type of an uploaded file:

from fastapi import FastAPI, UploadFile, File
from typing import Dict

app = FastAPI()

@app.post("/upload/")
async def upload_file(file: UploadFile = File(...)) -> Dict[str, str]:
    is_uploadfile_instance = isinstance(file, UploadFile)
    is_starlette_uploadfile_instance = isinstance(file, StarletteUploadFile)  # Assuming you imported it
    file_type = type(file)

    return {
        "is_UploadFile_instance": str(is_uploadfile_instance),
        "is_Starlette_UploadFile_instance": str(is_starlette_uploadfile_instance),
        "file_type": str(file_type),
        "filename": file.filename
    }

Here’s the crux of the confusion: when you perform the check with isinstance(file, UploadFile), you might expect it to return True, indicating that file is an instance of FastAPI's UploadFile. However, if you check the actual type of file, it will show as an instance of starlette.datastructures.UploadFile.

The reason for this is rooted in Python's class inheritance and how FastAPI structures its components. FastAPI’s UploadFile class inherits from Starlette’s UploadFile, so when you create an instance of FastAPI's UploadFile, it retains the base class type from Starlette.

Why Does This Matter?

Understanding this behavior is crucial for developers working with FastAPI, especially when debugging or writing type-dependent logic. The distinction highlights the elegance of FastAPI's design: it builds on established components from Starlette to provide a richer feature set while maintaining the underlying functionality. This allows developers to leverage the best of both worlds—the robust capabilities of Starlette combined with the advanced features of FastAPI.

Summary

The confusion regarding UploadFile instances in FastAPI arises from the framework's architectural choices. By importing UploadFile from FastAPI, you are utilizing a class that is a subclass of Starlette’s UploadFile. Consequently, type checks will reveal the underlying Starlette class, not the FastAPI wrapper.

In summary, while FastAPI extends and enhances the functionality of Starlette, it is important to remember that its components are built on top of these foundational classes. This design choice not only fosters efficiency but also maintains compatibility with existing standards in web development. Understanding this relationship allows developers to navigate the FastAPI landscape with greater clarity and confidence.

Additional Resources

To further explore the topics discussed in this blog, consider the following links:

• FastAPI Documentation: Upload File
• FastAPI UploadFile Class
• Starlette Documentation: UploadFile
• Understanding ASGI
• Starlette UploadFile Class
• Understanding FastAPI: How Starlette works