How to save UploadFile in FastAPI

You can save the uploaded files this way,

from fastapi import FastAPI, File, UploadFile

app = FastAPI()


@app.post("/upload-file/")
async def create_upload_file(uploaded_file: UploadFile = File(...)):
    file_location = f"files/{uploaded_file.filename}"
    with open(file_location, "wb+") as file_object:
        file_object.write(uploaded_file.file.read())
    return {"info": f"file '{uploaded_file.filename}' saved at '{file_location}'"}

You can also use the shutil.copyfileobj(...) method (see this detailed answer to how both are working behind the scenes).

So, as an alternative way, you can write something like the below using the shutil.copyfileobj(...) to achieve the file upload functionality.

import shutil
from fastapi import FastAPI, File, UploadFile

app = FastAPI()


@app.post("/upload-file/")
async def create_upload_file(uploaded_file: UploadFile = File(...)):    
file_location = f"files/{uploaded_file.filename}"
    with open(file_location, "wb+") as file_object:
        shutil.copyfileobj(uploaded_file.file, file_object)    
return {"info": f"file '{uploaded_file.filename}' saved at '{file_location}'"}

In my case, I need to handle huge files, so I must avoid reading them all into memory. What I want is to save them to disk asynchronously, in chunks.

I’m experimenting with this and it seems to do the job (CHUNK_SIZE is quite arbitrarily chosen, further tests are needed to find an optimal size):

import os
import logging

from fastapi import FastAPI, BackgroundTasks, File, UploadFile

log = logging.getLogger(__name__)

app = FastAPI()

DESTINATION = "/"
CHUNK_SIZE = 2 ** 20  # 1MB


async def chunked_copy(src, dst):
    await src.seek(0)
    with open(dst, "wb") as buffer:
        while True:
            contents = await src.read(CHUNK_SIZE)
            if not contents:
                log.info(f"Src completely consumedn")
                break
            log.info(f"Consumed {len(contents)} bytes from Src filen")
            buffer.write(contents)


@app.post("/uploadfile/")
async def create_upload_file(file: UploadFile = File(...)):
    fullpath = os.path.join(DESTINATION, file.filename)
    await chunked_copy(file, fullpath)
    return {"File saved to disk at": fullpath}

However, I’m quickly realizing that create_upload_file is not invoked until the file has been completely received. So, if this code snippet is correct it will probably be beneficial to performance but will not enable anything like providing feedback to the client about the progress of the upload and it will perform a full data copy in the server. It seems silly to not be able to just access the original UploadFile temporary file, flush it and just move it somewhere else, thus avoiding a copy.

you can save the file by copying and pasting the below code.

 fastapi import (
    FastAPI
    UploadFile,
    File,
    status
)
from fastapi.responses import JSONResponse

import aiofiles
app = FastAPI( debug = True ) 

@app.post("/upload_file/", response_description="", response_model = "")
async def result(file:UploadFile = File(...)):
     try:
        async with aiofiles.open(file.filename, 'wb') as out_file:
            content = await file.read()  # async read
            await out_file.write(content)  # async write

    except Exception as e:
        return JSONResponse(
            status_code = status.HTTP_400_BAD_REQUEST,
            content = { 'message' : str(e) }
            )
    else:
        return JSONResponse(
            status_code = status.HTTP_200_OK,
            content = {"result":'success'}
            )

If you wanted to upload the multiple file then copy paste the below code

 fastapi import (
    FastAPI
    UploadFile,
    File,
    status
)
from fastapi.responses import JSONResponse

import aiofiles
app = FastAPI( debug = True ) 
@router.post("/upload_multiple_file/", response_description="", response_model = "")

async def result(files:List[UploadFile] = File(...), secret_key: str = Depends(secretkey_middleware)):
    try:
        
        for file in files:

            async with aiofiles.open(eventid+file.filename, 'wb') as out_file:
                content = await file.read() 
                await out_file.write(content) 
                


        pass
    except Exception as e:
      
        return JSONResponse(
            status_code = status.HTTP_400_BAD_REQUEST,
            content = { 'message' : str(e) }
            )
    else:
        return JSONResponse(
            status_code = status.HTTP_200_OK,
            content = {"result":'result'}
            )

use this helper function to save the file

from fastapi import UploadFile

import shutil
from pathlib import Path

def save_upload_file(upload_file: UploadFile, destination: Path) -> str:
    try:
        with destination.open("wb") as buffer:
            shutil.copyfileobj(upload_file.file, buffer)
            file_name = buffer.name
            print(type(file_name))
    finally:
        upload_file.file.close()
    return file_name

use this function to give a unique name to each save file, assuming you will be saving more than one file

def unique_id():
    return str(uuid.uuid4())

def delete_file(filename):
    os.remove(filename)

in your endpoint

@router.post("/use_upload_file", response_model=dict)
async def use_uploaded_file(
    file_one: UploadFile = File(),
    file_two: UploadFile = File()
    ):


    file_one_path = save_upload_file(audio_one, Path(f"{unique_id()}"))
    file_two_path = save_upload_file(audio_two, Path(f"{unique_id()}"))

    result = YourFunctionThatUsestheSaveFile(audio_one_path, audio_two_path)

    delete_file(audio_one_path)
    delete_file(audio_two_path)

    return result

Code to upload file in fast-API through Endpoints (post request):

@router.post(path="/test", tags=['File Upload'])
def color_classification_predict(uploadFile: UploadFile):
    try:
        if uploadFile.filename:
            # saved_dir- directory path where we'll save the uploaded file 
            test_filename = os.path.join(saved_dir, uploadFile.filename)
            with open(test_filename, "wb+") as file_object:
                shutil.copyfileobj(uploadFile.file, file_object)
    except Exception as e:
        raise e
    print('[INFO] Uploaded file saved.')

Just did this to upload a file and works fine.

from fastapi import APIRouter, File, status, Depends, HTTPException,  UploadFile

import shutil
from pathlib import Path

from database.user_functions import *
from database.auth_functions import *
from database.form_functions import *

from model import *
from model_form import *

file_routes = APIRouter()


# @file_routes.post("/files/")
# async def create_file(file: bytes = File()):
#     return {"file_size": len(file)}


# @file_routes.post("/uploadfile/")
# async def create_upload_file(file: UploadFile):
#     return {"filename": file.filename}


@file_routes.post("/upload-file/")
async def create_upload_file(uploaded_file: UploadFile = File(...)):    

    file_location = f"./{uploaded_file.filename}"
    with open(file_location, "wb+") as file_object:
        shutil.copyfileobj(uploaded_file.file, file_object)    
    return {"info": f"file '{uploaded_file.filename}' saved at '{file_location}'"}

tbh I did found it on a medium article