FastAPI Handling File Uploads

How does FastAPI handle file uploads?

FastAPI allows you to handle file uploads using the File and UploadFile classes. The File class is used to read small files, while UploadFile is designed for handling larger file uploads, offering a more efficient way to handle file I/O by streaming the file.

What is the difference between File and UploadFile in FastAPI?

File reads the entire file into memory and is suitable for small files, while UploadFile is more efficient for larger files as it doesn't load the entire file into memory. UploadFile provides additional methods for working with files, such as saving, reading, and streaming data.

Example of using File:

from fastapi import FastAPI, File

app = FastAPI()

@app.post("/uploadfile/")
async def create_upload_file(file: bytes = File(...)):
    return {"file_size": len(file)}

In this example, the file is read as bytes using File and the size of the file is returned in the response.

Example of using UploadFile:

from fastapi import FastAPI, UploadFile

app = FastAPI()

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

In this example, UploadFile is used to upload a file and return its filename. This is more efficient for larger files as the file is streamed rather than fully loaded into memory.

How do you upload multiple files in FastAPI?

FastAPI allows you to upload multiple files by accepting a list of UploadFile objects. Each file is handled individually, and the client can send multiple files in a single request.

Example of uploading multiple files:

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

app = FastAPI()

@app.post("/uploadfiles/")
async def upload_files(files: List[UploadFile]):
    return {"filenames": [file.filename for file in files]}

In this example, a list of files is accepted, and the filenames are returned. The files can be processed individually in the backend.

How do you save uploaded files to disk in FastAPI?

You can save uploaded files to disk using the UploadFile class's .file attribute, which gives access to the file-like object. You can use the write() method to save the file to a desired location on your server.

Example of saving an uploaded file to disk:

from fastapi import FastAPI, UploadFile
import shutil

app = FastAPI()

@app.post("/upload/")
async def save_upload_file(file: UploadFile):
    with open(f"files/{file.filename}", "wb") as buffer:
        shutil.copyfileobj(file.file, buffer)
    return {"filename": file.filename}

In this example, the uploaded file is saved to the files/ directory using the shutil.copyfileobj() method to stream the file data and write it to the disk.

How do you handle file uploads with additional form data in FastAPI?

You can combine file uploads with form data by using both UploadFile for the file and Form for the form fields. This allows you to handle both file data and additional form input in the same request.

Example of handling file uploads with form data:

from fastapi import FastAPI, UploadFile, Form

app = FastAPI()

@app.post("/upload/")
async def upload_with_form_data(file: UploadFile, description: str = Form(...)):
    return {"filename": file.filename, "description": description}

In this example, a file is uploaded along with a description provided via a form field. Both the file and description are returned in the response.

How do you limit file size in FastAPI uploads?

FastAPI does not have built-in mechanisms to limit file size directly, but you can enforce size limits by checking the file size in your route handler and returning an error response if the file exceeds the allowed limit.

Example of limiting file size:

from fastapi import FastAPI, UploadFile, HTTPException

app = FastAPI()

MAX_FILE_SIZE = 5 * 1024 * 1024  # 5 MB

@app.post("/upload/")
async def upload_file(file: UploadFile):
    contents = await file.read()
    if len(contents) > MAX_FILE_SIZE:
        raise HTTPException(status_code=400, detail="File too large")
    return {"filename": file.filename}

In this example, the file size is checked after reading the file, and an error is returned if it exceeds 5 MB.

How do you validate file types in FastAPI uploads?

You can validate file types in FastAPI by checking the file's content type (MIME type) or by inspecting the file's extension. The UploadFile object provides access to the content_type attribute, which contains the MIME type of the uploaded file.

Example of validating file types:

from fastapi import FastAPI, UploadFile, HTTPException

app = FastAPI()

@app.post("/upload/")
async def upload_file(file: UploadFile):
    if file.content_type not in ["image/jpeg", "image/png"]:
        raise HTTPException(status_code=400, detail="Invalid file type")
    return {"filename": file.filename}

In this example, the file is only accepted if its MIME type is image/jpeg or image/png. If the file type is invalid, an error is returned.

How do you handle large file uploads efficiently in FastAPI?

For large file uploads, FastAPI's UploadFile class is the recommended approach because it streams the file instead of reading it into memory. This helps you handle large files without running into memory issues. You can also save the file to disk in chunks as it is being uploaded, further improving efficiency.

Example of handling large files:

from fastapi import FastAPI, UploadFile
import shutil

app = FastAPI()

@app.post("/upload/")
async def upload_large_file(file: UploadFile):
    with open(f"large_files/{file.filename}", "wb") as buffer:
        shutil.copyfileobj(file.file, buffer)
    return {"filename": file.filename}

In this example, shutil.copyfileobj() is used to efficiently stream the file data from the uploaded file to the disk, making it suitable for handling large files.

How do you test file uploads in FastAPI?

You can test file uploads in FastAPI using the TestClient class provided by FastAPI. When testing file uploads, you can simulate a file being uploaded by providing it as a tuple containing the file name, content, and MIME type.

Example of testing file uploads:

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

app = FastAPI()
client = TestClient(app)

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

def test_upload_file():
    file = ("test.txt", b"file content", "text/plain")
    response = client.post("/upload/", files={"file": file})
    assert response.status_code == 200
    assert response.json() == {"filename": "test.txt"}

In this example, the test simulates an upload of a text file, and the response is checked to ensure that the file upload was handled correctly.