Artikel ini memperincikan bagaimana untuk menyediakan fail dengan selamat dan cekap (seperti audio, pdf, dan lain -lain) yang dijana pada pelayan kepada pengguna untuk dimuat turun selepas memproses permintaan pos dalam aplikasi FastAPI. Artikel ini merangkumi dua kaedah pelaksanaan utama: satu adalah untuk terus mengembalikan muat turun fail melalui permintaan pos, dan yang lain adalah untuk menggabungkan JavaScript front-end untuk muat turun fail asynchronous, dan sangat membincangkan penggunaan komponen teras seperti `fileresponse` dan` streamingresponse`, serta file cleaning dan surve file.

Apabila membina aplikasi web, keperluan umum ialah selepas pengguna menyerahkan data melalui borang, sisi pelayan memprosesnya dan menghasilkan fail, dan kemudian menyediakan fail kepada pengguna untuk dimuat turun. Sebagai contoh, dalam perkhidmatan teks-ke-ucapan, selepas pengguna memasuki teks, pelayan menghasilkan fail MP3 dan membolehkan pengguna memuat turunnya. FastAPI menyediakan mekanisme yang fleksibel dan berkuasa untuk mengendalikan senario tersebut.

1. Muat turun fail terus melalui permintaan pos

Cara yang paling mudah adalah untuk mengembalikan fail sebagai respons sebaik sahaja ia dihasilkan, di titik akhir yang mengendalikan permintaan pos. FileResponse FastAPI adalah komponen utama untuk mencapai fungsi ini.

1. Konsep dan pelaksanaan teras

Untuk memastikan bahawa fail dimuat turun dan bukannya dipratonton dalam penyemak imbas, kita perlu menetapkan kandungan kandungan dalam tajuk tindak balas.

Contoh App.py:

 Dari Fastapi Import Fastapi, Permintaan, Borang, Latar Belakang
dari fastapi.templating import jinja2templates
dari fastapi.Sespons Import FileResponse, Response, StreamingResponse
Import OS
Import uvicorn

app = fastapi ()
templat = jinja2templates (direktori = "templat")

# Anggap fail disimpan dalam Direktori Temp temp_dir = "./Temp"
jika tidak os.path.exists (temp_dir):
    os.makedirs (temp_dir)

# Simulasi fungsi teks-ke-ucapan def def text_to_speech_mock (bahasa: str, teks: str)-> str:
    "" "Simulasi teks-ke-ucapan dan menghasilkan fail mp3" ""
    filePath = os.path.join (temp_dir, "selamat datang.mp3")
    # Dalam aplikasi sebenar, GTTS atau perpustakaan TTS lain akan dipanggil dengan Open (FilePath, "W") sebagai F:
        f.write (f "kandungan audio mock untuk '{text}' dalam '{language}'")
    cetak (f "dihasilkan mock mp3 di: {filePath}")
    kembali filePath

@app.get ('/')
async def utama (permintaan: permintaan):
    "" "Laman Utama, Menyediakan Borang" ""
    Template kembali

@app.post ('/text2speech_direct')
async def convert_and_download_direct (
    Permintaan: Permintaan,
    Mesej: str = form (...),
    Bahasa: str = form (...),
    latar belakang_tasks: latar belakangTasks = tiada
):
    "" "
    Mengendalikan teks-ke-ucapan secara langsung melalui permintaan pos dan muat turun fail kembali.
    Gunakan borang (...) untuk memastikan parameter dihuraikan dengan betul.
    "" "
    cetak (f "mesej yang diterima: {mesej}, bahasa: {bahasa}")
    filePath = text_to_speech_mock (bahasa, mesej) # simulasi yang dihasilkan fail fail = os.path.basename (filePath)
    tajuk = {
        'Kandungan-disposisi': f'attachment; filename = "{filename}" '
    }

    # Tambah tugas latar belakang untuk memadam fail setelah dimuat turun jika latar belakang_tasks:
        latar belakang_tasks.add_task (os.remove, filePath)
        cetak (f "penghapusan yang dijadualkan untuk: {filePath}")

    Kembali FileResponse (filePath, headers = headers, media_type = "audio/mp3")

jika __name__ == "__main__":
    uvicorn.run (app, host = "127.0.0.1", port = 8000)

Templat/index.html Contoh:

 

   
      <twit> Tukar teks ke ucapan (muat turun langsung) 
   
   
      <h2> Teks ke Ucapan dan Muat turun Langsung </h2>
      <form method="post" action="/text2speech_direct">
         <label untuk="mesej"> Mesej: </label>
         <input type="text" id="message" name="message" value="Ini adalah mesej sampel"> <br> <br>
         <label untuk="bahasa"> bahasa: </label>
         <input type="text" id="language" name="language" value="en"> <br> <br>
         <input type="hantar" value="hantar dan muat turun">
      </form>
   
</twit>

Perkara yang perlu diperhatikan:

• Borang (...) digunakan untuk menghuraikan data bentuk dari badan permintaan dan mengisytiharkannya sebagai parameter yang diperlukan.
• FileResponse akan membaca kandungan fail dalam blok (lalai 64KB), yang sesuai untuk kebanyakan senario muat turun fail.
• Kandungan Kandungan: Lampiran; FileName = "..." tajuk adalah kunci untuk memaksa penyemak imbas untuk memuat turun fail. Jika tajuk ini hilang atau parameter sebaris digunakan, penyemak imbas boleh cuba memaparkan kandungan fail sejajar, yang mungkin mengakibatkan kaedah 405 tidak dibenarkan ralat sebagai penyemak imbas cuba mengakses fail menggunakan permintaan GET.
• Media_Type harus ditetapkan ke jenis mime fail, seperti audio/mp3.

2. Alternatif: Respons dan StreamingResponse

Dalam beberapa senario tertentu, fileResponse mungkin bukan pilihan terbaik:

• Kandungan fail telah dimuatkan sepenuhnya ke dalam memori: Jika kandungan fail sudah ada dalam ingatan sebagai aliran byte atau rentetan, ia boleh dikembalikan secara langsung menggunakan respons.

   dari respons import fastapi
  #...
  @app.post ('/text2speech_in_memory')
  async def convert_and_download_in_memory (mesej: str = form (...), bahasa: str = form (...)):
      # Anggapkan bahawa kandungan fail telah dihasilkan dalam memori # contohnya: kandungan = penjana_udio_bytes (mesej, bahasa)
      filePath = text_to_speech_mock (bahasa, mesej) # simulasi fail yang dihasilkan dengan terbuka (filePath, "rb") sebagai f:
          kandungan = f.read () # baca kandungan fail ke dalam fail memori = os.path.basename (filePath)
      headers = {'content-disposition': f'attachment; filename = "{filename}" '}
      Tindak Balas Kembali (Kandungan, Headers = Headers, Media_Type = 'Audio/mp3')

• Fail terlalu besar untuk memuatkan memori dalam satu perjalanan: Untuk fail yang sangat besar (contohnya, fail dalam puluhan GB), StreamingResponse adalah pilihan yang lebih baik. Ia membolehkan memuatkan dan menghantar kandungan fail dalam ketulan kecil, mengelakkan limpahan memori.

   dari fastapi.Sespons Import StreamingResponse
  #...
  @app.post ('/text2speech_streaming')
  async def convert_and_download_streaming (mesej: str = form (...), bahasa: str = form (...)):
      filePath = text_to_speech_mock (bahasa, mesej) # simulasi dihasilkan fail def iterfile ():
          dengan terbuka (filePath, "rb") sebagai f:
              Hasil dari F # Baca blok fail dengan blok filename = os.path.basename (filePath)
      headers = {'content-disposition': f'attachment; filename = "{filename}" '}
      Kembali StreamingResponse (iterFile (), headers = headers, media_type = "audio/mp3")

  Walaupun FileResponse juga menyokong bacaan chunked, saiz bahagiannya tetap (64KB). StreamingResponse memberikan fleksibiliti yang lebih besar jika anda perlu menyesuaikan saiz blok untuk mengoptimumkan prestasi.

2. Muat turun fail melalui permintaan asynchronous dan javascript

Apabila interaksi yang lebih kompleks diperlukan, pengendalian permintaan pengguna serentak, atau menghasilkan nama fail secara dinamik, lebih mantap untuk memecah penjanaan fail dan muat turun fail ke dalam dua langkah dan menyelaraskannya melalui JavaScript front-end.

1. Konsep dan pelaksanaan teras

Aliran kerja senario ini adalah seperti berikut:

1. Pengguna menghantar data melalui borang.
2. Pelayan memproses data dan menghasilkan fail, tetapi tidak mengembalikan fail secara langsung .
3. Pelayan menghasilkan pengenal yang unik (seperti UUID) dan mengaitkannya dengan laluan fail, kemudian mengembalikan pengecam tersebut (atau pautan muat turun yang mengandungi pengenal) ke hujung depan.
4. Selepas menerima pengenal, hujung depan menggunakan JavaScript untuk mengemas kini secara dinamik pautan muat turun atau memulakan permintaan GET baru untuk memuat turun fail.

Contoh App.py:

 Dari Fastapi Import Fastapi, Permintaan, Borang, Latar Belakang
dari fastapi.templating import jinja2templates
dari fastapi.Sespons Import FileResponse
import uuid
Import OS
Import uvicorn

app = fastapi ()
templat = jinja2templates (direktori = "templat")

Temp_dir = "./temp"
jika tidak os.path.exists (temp_dir):
    os.makedirs (temp_dir)

# Kamus untuk mensimulasikan storan fail (pangkalan data atau cache harus digunakan dalam persekitaran pengeluaran sebenar)
files_to_download = {}

# Simulasi fungsi teks-ke-ucapan def def text_to_speech_mock_unique (bahasa: str, teks: str)-> str:
    "" "Simulasi teks-ke-ucapan dan menghasilkan nama fail dengan uuid" ""
    unik_filename = f "welcome_ {uuid.uuid4 (). hex} .mp3"
    filePath = os.path.join (temp_dir, unik_filename)
    dengan terbuka (filePath, "w") sebagai f:
        f.write (f "kandungan audio mock untuk '{text}' dalam '{language}'")
    cetak (f "dihasilkan mock mp3 di: {filePath}")
    kembali filePath

# Tugas Latar Belakang: Padam Fail dan Cache Cache DEF Rove_file_and_cache (filePath: str, file_id: str):
    jika os.path.exists (filePath):
        OS.Remove (FilePath)
        cetak (f "fail yang dipadam: {filePath}")
    jika file_id dalam fail_to_download:
        del files_to_download [file_id]
        cetak (f "dikeluarkan file_id dari cache: {file_id}")

@app.get ('/')
async def main_async (permintaan: permintaan):
    "" "Laman Utama, Menyediakan Borang" ""
    Template kembali

@app.post ('/text2speech_async')
async def convert_and_get_download_link (
    Permintaan: Permintaan,
    Mesej: str = form (...),
    Bahasa: str = form (...)
):
    "" "
    Proses teks-ke-ucapan, menjana fail, dan kembalikan ID pautan muat turun.
    "" "
    cetak (f "diterima mesej untuk async: {message}, bahasa: {language}")
    filePath = text_to_speech_mock_unique (bahasa, mesej) # simulasi yang dihasilkan fail file_id = str (uuid.uuid4 ())
    files_to_download [file_id] = filePath # Laluan fail bersekutu dengan file_url id unik = f '/muat turun_async? fileId = {file_id}'
    kembali {"fileUrl": file_url}

@app.get ('/muat turun_async')
async def download_file_async (
    Permintaan: Permintaan,
    FileId: str,
    latar belakang_tasks: latar belakang
):
    "" "
    Muat turun fail berdasarkan ID fail.
    "" "
    filePath = files_to_download.get (fileId)
    Sekiranya FilePath dan OS.Path.Exists (FilePath):
        FileName = os.path.BaseName (FilePath)
        headers = {'content-disposition': f'attachment; filename = "{filename}" '}

        # Tambahkan tugas latar belakang untuk mengeluarkan fail setelah memuat turun latar belakang_tasks.add_task (rove_file_and_cache, filePath = filePath, file_id = fileId)
        cetak (f "penghapusan yang dijadualkan untuk: {filePath} dengan id: {fileId}")

        Kembali FileResponse (filePath, headers = headers, media_type = 'audio/mp3')

    # Sekiranya ID Fail tidak sah atau fail tidak wujud, kembali 404
    Tanggapan kembali (status_code = 404, kandungan = "Fail tidak dijumpai atau tamat tempoh.")

jika __name__ == "__main__":
    uvicorn.run (app, host = "127.0.0.1", port = 8000)

Templat/index.html Contoh:

 

   
      <tirtle> Tukar teks ke ucapan (muat turun async) 
   
   
      <h2> muat turun teks-ke-ucapan dan asynchronous </h2>
      <form kaedah="pos" id="myForm">
         <label for="message_async"> Mesej: </label>
         <input type="text" id="message_async" name="message" value="Ini adalah mesej sampel async"> <br> <br>
         <label for="language_async"> Bahasa: </label>
         <input type="text" id="language_async" name="language" value="en"> <br> <br>
         <input type="butang" value="Hantar dan dapatkan pautan muat turun" onclick="hantarFormAsync ()">
      </form>

      <p> <a id="muat turun" href="" style="paparan: none;"> </a> </p>

      <script type="text/javascript">
         fungsi hantarFormAsync () {
             var formElement = document.getElementById (&#39;myForm&#39;);
             var data = formData baru (formElement);

             Ambil (&#39;/text2speech_async&#39;, {
                   Kaedah: &#39;pos&#39;,
                   badan: data,
                 })
                 .then (response => response.json ())
                 .THEN (data => {
                   jika (data.fileUrl) {
                     var downloadLink = document.getElementById ("muat turun");
                     muat turunLink.href = data.fileUrl;
                     muat turunKink.innerHtml = "Klik untuk memuat turun fail";
                     muat turunLink.style.display = "block"; // pautan muat turun paparan} else {
                     Console.error ("Tiada FileUrl diterima.");
                   }
                 })
                 .catch (error => {
                   Console.error ("Borang penyerahan ralat:", ralat);
                 });
         }
      </script>
   
</tirtle>

Perkara yang perlu diperhatikan:

• Pengurusan ID Fail: Dalam persekitaran pengeluaran, kamus files_to_download harus digantikan dengan penyelesaian penyimpanan yang lebih tahan lama dan berskala, seperti pangkalan data, sistem cache seperti REDIS, untuk menyokong penggunaan multi-proses/multi-server dan pengurusan kitaran hayat yang lebih kompleks.
• Keselamatan: ID Fail (UUID) agak selamat untuk lulus sebagai parameter pertanyaan kerana sukar untuk diteka. Tetapi anda tidak boleh lulus maklumat sensitif dalam rentetan pertanyaan . Data sensitif harus diluluskan melalui badan permintaan atau pengurusan sesi yang selamat (seperti cookies HTTP sahaja), dan selalu menggunakan protokol HTTPS.
• JavaScript Front-end: Gunakan API Fetch untuk memulakan permintaan Pos Asynchronous, dapatkan pautan muat turun yang dikembalikan oleh pelayan, dan kemudian mengemas kini tag secara dinamik pada halaman.

3. Pembersihan fail dan tugas latar belakang

Untuk mengelakkan sejumlah besar fail sementara yang terkumpul di pelayan, adalah penting untuk membersihkan fail yang dimuat turun atau tamat tempoh tepat pada masanya. FastAPI menyediakan latar belakang untuk mencapai tujuan ini.

1. Penggunaan latar belakang latar belakang

Latar Belakang membolehkan anda melakukan beberapa tugas di latar belakang selepas respons HTTP dihantar kepada pelanggan. Ini bagus untuk pembersihan fail.

• Untuk penyelesaian muat turun langsung (pilihan 1):

   dari fastapi import latar belakang
  Import OS
  
  @app.post ('/text2speech_direct')
  async def convert_and_download_direct (
      # ... Parameter Lain Latar Belakang_tasks: Latar Belakang: Suntikan Latar Belakang
  ):
      filePath = text_to_speech_mock (bahasa, mesej)
      # ... LOGIC LATAR BELAKANG_TASKS.ADD_TASK (OS.REMOVE, FILEPATH) # Tambah tugas latar belakang untuk memadam fail fileResponse (filePath, headers = headers, media_type = "audio/mp3")

• Untuk skema muat turun asynchronous (pilihan 2): Dalam skema muat turun asynchronous, kerana pemetaan ID fail dan laluan fail disimpan dalam kamus files_to_download, selain memadam fail, pemetaan ini juga perlu dibersihkan. Oleh itu, fungsi penolong boleh ditakrifkan untuk mencapai kedua -dua tugas.

   dari fastapi import latar belakang
  Import OS
  
  # ... files_to_download kamus definisi def rove_file_and_cache (filePath: str, file_id: str):
      "" "Padam fail dan keluarkan ID dari cache" ""
      jika os.path.exists (filePath):
          OS.Remove (FilePath)
      jika file_id dalam fail_to_download:
          del files_to_download [file_id]
  
  @app.get ('/muat turun_async')
  async def download_file_async (
      # ... Parameter Lain Latar Belakang_tasks: Latar Belakang
  ):
      filePath = files_to_download.get (fileId)
      Sekiranya FilePath dan OS.Path.Exists (FilePath):
          # ... LOGIC LAGI LAIN_TASKS.ADD_TASK (REAVE_FILE_AND_CACHE, FILEPATH = FILEPATH, FILE_ID = FILEID)
          Kembali FileResponse (filePath, headers = headers, media_type = 'audio/mp3')
      # ... pengendalian ralat

Meringkaskan

FastAPI menyediakan pelbagai cara yang fleksibel untuk mengendalikan keperluan muat turun fail selepas permintaan pos.

• Muat turun langsung (FileResponse) sesuai untuk senario mudah. Muat turun fail secara langsung dicetuskan selepas pengguna mengemukakan borang.
• Muat turun asynchronous (digabungkan dengan JavaScript dan ID unik) lebih sesuai untuk senario fail yang kompleks, berbilang pengguna, dinamik, dan ia memberikan pengalaman pengguna yang lebih baik dan skalabilitas yang lebih kuat.

Tidak kira kaedah mana yang anda pilih, anda harus memberi perhatian kepada perkara berikut:

• Header Kandungan-Kandungan: Pastikan ia ditetapkan dengan betul untuk memaksa penyemak imbas untuk memuat turun fail.
• Pembersihan Fail: Gunakan latar belakang untuk memadam fail sementara tepat pada masanya untuk mengelakkan kebocoran sumber.
• Concurrency and Scaling: Dalam persekitaran berbilang pengguna atau diedarkan, pertimbangkan untuk menggunakan pangkalan data atau cache untuk menguruskan pemetaan ID dan laluan fail.
• Keselamatan: Elakkan lulus maklumat sensitif dalam parameter pertanyaan URL dan sentiasa menggunakan HTTPS.

Dengan memilih dan menggabungkan teknologi ini dengan betul, perkhidmatan muat turun fail Fastapi yang cekap dan mantap boleh dibina.

Atas ialah kandungan terperinci Panduan untuk memuat turun fail selepas permintaan pos fastapi. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!