如何解决FastAPI的大文件传输问题

import time
from fastapi import FastAPI, UploadFile, Request

app = FastAPI()


@app.post("/uploadfile/")
async def create_upload_file(file: UploadFile) -> dict:
    print(len(await file.read()))
    return {"filename": file.filename}


@app.post("/streamfile/")
async def create_file(request: Request):
    chunks: list[bytes] = []
    async for chunk in request.stream():
        chunks.append(chunk)
    print(len(chunks))
    return request.headers.get("filename")


import uvicorn
uvicorn.run(app)

from starlette.formparsers import MultiPartParser

MultiPartParser.max_file_size = 20 * 1024 * 1024

import tempfile

# 修改临时文件目录
tempfile.tempdir = "path/to/tempdir/here"

from starlette.formparsers import MultiPartParser

# 修改该配置，使所有文件都会直接存放到硬盘中
MultiPartParser.max_file_size = 0 

from fastapi import FastAPI, Request
from multipart import PushMultipartParser, MultipartSegment, parse_options_header

app = FastAPI()


@app.post("/streamfile/")
async def create_file(request: Request):
    content_type = request.headers.get("content-type")
    real_content_type, boundary_dict = parse_options_header(content_type)
    assert real_content_type == "multipart/form-data"

    filename: str = ""
    file_length: int = 0
    stream_gen = request.stream()

    with PushMultipartParser(boundary_dict["boundary"]) as parser:
        while not parser.closed:
            chunk = await stream_gen.__anext__()
            for result in parser.parse(chunk):
                if isinstance(result, MultipartSegment):
                    print(f"== Start of segment: {result.name}")
                    if result.filename:
                        filename = result.filename
                        print(f"== Client-side filename: {result.filename}")
                    for header, value in result.headerlist:
                        print(f"{header}: {value}")
                elif result:  # Result is a non-empty bytearray
                    file_length += len(result)
                else:  # Result is None
                    print(f"== End of segment")

    return {"filename": filename, "length": file_length}


import uvicorn
uvicorn.run(app)

from fastapi import FastAPI
from fastapi.staticfiles import StaticFiles

app = FastAPI()
app.mount("/static", StaticFiles(directory="static"), name="static")

import uvicorn
uvicorn.run(app)

import asyncio
from aiohttp import web

routes = web.RouteTableDef()
routes.static("/static", "./static")

app = web.Application()
app.add_routes(routes)

def main(port=8000):
    loop = asyncio.new_event_loop()
    web.run_app(app, port=port, loop=loop)

if __name__ == '__main__':
    main()

# 0.39版本后新增了if-range的处理，代码会更多，这里以0.38版本代码为准
class FileResponse(Response):
    ...
    async def __call__(self, scope: Scope, receive: Receive, send: Send) -> None:
        ...
        await send(
            {
                "type": "http.response.start",
                "status": self.status_code,
                "headers": self.raw_headers,
            }
        )
        if scope["method"].upper() == "HEAD":
            await send({"type": "http.response.body", "body": b"", "more_body": False})
        else:
            # >>>主要逻辑
            async with await anyio.open_file(self.path, mode="rb") as file:
                more_body = True
                while more_body:
                    chunk = await file.read(self.chunk_size)
                    more_body = len(chunk) == self.chunk_size
                    await send(
                        {
                            "type": "http.response.body",
                            "body": chunk,
                            "more_body": more_body,
                        }
                    )
        if self.background is not None:
            await self.background()

class FileResponse(StreamResponse):
    ...
    async def _sendfile_fallback(
        self, writer: AbstractStreamWriter, fobj: IO[Any], offset: int, count: int
    ) -> AbstractStreamWriter:

        chunk_size = self._chunk_size
        loop = asyncio.get_event_loop()

        await loop.run_in_executor(None, fobj.seek, offset)

        chunk = await loop.run_in_executor(None, fobj.read, chunk_size)
        while chunk:
            await writer.write(chunk)
            count = count - chunk_size
            if count <= 0:
                break
            chunk = await loop.run_in_executor(None, fobj.read, min(chunk_size, count))

        await writer.drain()
        return writer

    async def _sendfile(
        self, request: "BaseRequest", fobj: IO[Any], offset: int, count: int
    ) -> AbstractStreamWriter:
        writer = await super().prepare(request)
        assert writer is not None

        if NOSENDFILE or self.compression:
            return await self._sendfile_fallback(writer, fobj, offset, count)

        loop = request._loop
        transport = request.transport
        assert transport is not None

        try:
            await loop.sendfile(transport, fobj, offset, count)
        except NotImplementedError:
            return await self._sendfile_fallback(writer, fobj, offset, count)

        await super().write_eof()
        return writer

from fastapi import Response, FastAPI


async def file_route(file_name: str) -> Response:
    resp = Response()
    resp.headers["X-Sendfile"] = f"/private_files/{file_name}"
    return resp


app = FastAPI()
app.add_route("/api/file/{file_name}", file_route, methods=["GET"])


if __name__ == "__main__":
    import uvicorn
    uvicorn.run(app)