Maison > Article > développement back-end > Comment télécharger un fichier après avoir publié des données à l'aide de FastAPI ?

Comment télécharger un fichier après avoir publié des données à l'aide de FastAPI ?

Barbara Streisandoriginal: 2024-10-31 20:25:17995parcourir

How to Download a File after POSTing Data Using FastAPI?

Comment télécharger un fichier après avoir publié des données à l'aide de FastAPI ?

Lorsque vous travaillez avec FastAPI et la gestion des fichiers, une tâche courante consiste à permettre aux utilisateurs de télécharger un fichier après l'avoir soumis. données via une requête POST. Ceci peut être réalisé en utilisant la classe FileResponse et en garantissant la configuration appropriée des en-têtes et du type de contenu.

Dans le code fourni ci-dessous, nous montrerons comment configurer un point de terminaison POST qui traite les données et renvoie un audio. fichier (MP3) à télécharger. Nous utiliserons le type de données Form pour capturer les entrées de l'utilisateur et générer le fichier audio.

Option 1 : Utiliser un point de terminaison de téléchargement distinct

Dans cette approche, nous créerons un point de terminaison distinct pour gestion des téléchargements de fichiers.

<code class="python">from fastapi import FastAPI, Request, Form, File, UploadFile
from fastapi.responses import FileResponse, HTMLResponse
from fastapi.templating import Jinja2Templates
from gtts import gTTS

app = FastAPI()
templates = Jinja2Templates(directory="templates")


def text_to_speech(language: str, text: str) -> str:
    tts = gTTS(text=text, lang=language, slow=False)
    filepath = "temp/welcome.mp3"
    tts.save(filepath)
    return f"Text to speech conversion successful to {filepath}"


@app.get("/")
def home(request: Request):
    return templates.TemplateResponse("index.html", {"request": request})


@app.post("/text2speech")
def text2speech(request: Request, message: str = Form(...), language: str = Form(...)):
    if message and language:
        output = text_to_speech(language, message)
    path = "temp/welcome.mp3"
    filename = os.path.basename(path)
    headers = {"Content-Disposition": f"attachment; filename={filename}"}
    return FileResponse(path, headers=headers, media_type="audio/mp3")</code>

Le point de terminaison GET sert de page principale, tandis que le point de terminaison POST gère les entrées de l'utilisateur et génère le fichier audio. FileResponse se charge de définir les en-têtes appropriés pour le téléchargement du fichier.

Dans votre modèle, vous pouvez ajouter un lien pour déclencher le téléchargement du fichier :

<code class="html"><!DOCTYPE html>
<html>
  <head>
    <title>Download File</title>
  </head>
  <body>
    <a href="{{ url_for('text2speech') }}">Download File</a>
  </body>
</html></code>

Option 2 : Fichier In-Endpoint Télécharger

Vous pouvez également gérer le téléchargement du fichier au sein du même point de terminaison qui traite les données :

<code class="python">from fastapi import FastAPI, Request, Form

app = FastAPI()


def text_to_speech(language: str, text: str) -> str:
    tts = gTTS(text=text, lang=language, slow=False)
    filepath = "temp/welcome.mp3"
    tts.save(filepath)
    return f"Text to speech conversion successful to {filepath}"


@app.post("/text2speech")
def text2speech(request: Request, message: str = Form(...), language: str = Form(...)):
    output = text_to_speech(language, message)
    return {"filepath": filepath}</code>

Dans votre modèle, vous pouvez utiliser JavaScript pour déclencher le téléchargement du fichier à l'aide du chemin de fichier renvoyé par le point de terminaison :

<code class="html"><script>
  const filepath = "{{ filepath }}";
  window.location.href = filepath;
</script></code>

Gestion des fichiers volumineux

Pour les fichiers dépassant les limites de mémoire, vous pouvez utiliser StreamingResponse :

<code class="python">from fastapi.responses import StreamingResponse

@app.post("/text2speech")
def text2speech(request: Request, message: str = Form(...), language: str = Form(...)):
    ...
    def iterfile():
        with open(filepath, "rb") as f:
            yield from f

    headers = {"Content-Disposition": f"attachment; filename={filename}"}
    return StreamingResponse(iterfile(), headers=headers, media_type="audio/mp3")</code>

Suppression des fichiers après le téléchargement

Pour éviter l'accumulation d'espace disque, il est recommandé de supprimer les fichiers une fois qu'ils ont été téléchargés. À l'aide de BackgroundTasks, vous pouvez planifier la suppression du fichier en tâche de fond :

<code class="python">from fastapi import BackgroundTasks

@app.post("/text2speech")
def text2speech(request: Request, background_tasks: BackgroundTasks, ...):
    ...
    background_tasks.add_task(os.remove, path=filepath)
    return FileResponse(filepath, headers=headers, media_type="audio/mp3")</code>

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!

JavaScript fastapi for while using class delete this background input

Déclaration：

Le contenu de cet article est volontairement contribué par les internautes et les droits d'auteur appartiennent à l'auteur original. Ce site n'assume aucune responsabilité légale correspondante. Si vous trouvez un contenu suspecté de plagiat ou de contrefaçon, veuillez contacter admin@php.cn

Article précédent：Comment puis-je obtenir les adresses IP des visiteurs à l'aide de Flask ?Article suivant：Comment puis-je obtenir les adresses IP des visiteurs à l'aide de Flask ?

Articles Liés

Voir plus