FastAPI फ़ाइल अपलोड में महारत हासिल करना: मल्टीपार्ट फ़ॉर्म प्रोसेसिंग में गहराई से

आधुनिक वेब अनुप्रयोगों में, फ़ाइल अपलोड को संभालने की क्षमता एक मूलभूत आवश्यकता है। चाहे वह उपयोगकर्ता प्रोफ़ाइल चित्र, प्रसंस्करण के लिए दस्तावेज़, या साझा करने के लिए मीडिया सबमिट कर रहे हों, मजबूत और कुशल फ़ाइल अपलोड तंत्र महत्वपूर्ण हैं। FastAPI, एक उच्च-प्रदर्शन पायथन वेब फ्रेमवर्क, इस डोमेन में उत्कृष्टता प्राप्त करता है, जो मल्टीपार्ट फॉर्म डेटा को प्रबंधित करने के लिए सुव्यवस्थित तरीके प्रदान करता है, जो HTTP पर फ़ाइलें भेजने के लिए मानक है। यह व्यापक गाइड आपको बुनियादी कार्यान्वयन से लेकर उन्नत विचारों तक, FastAPI फ़ाइल अपलोड की जटिलताओं के बारे में बताएगा, जिससे यह सुनिश्चित होगा कि आप आत्मविश्वास से वैश्विक दर्शकों के लिए शक्तिशाली और स्केलेबल API बना सकते हैं।

मल्टीपार्ट फ़ॉर्म डेटा को समझना

FastAPI के कार्यान्वयन में जाने से पहले, यह समझना आवश्यक है कि मल्टीपार्ट फ़ॉर्म डेटा क्या है। जब एक वेब ब्राउज़र फ़ाइलों वाले फ़ॉर्म को सबमिट करता है, तो यह आमतौर पर enctype="multipart/form-data" विशेषता का उपयोग करता है। यह एन्कोडिंग प्रकार फ़ॉर्म सबमिशन को कई भागों में तोड़ देता है, प्रत्येक का अपना कंटेंट टाइप और डिस्पोज़िशन जानकारी होती है। यह पाठ फ़ील्ड, गैर-पाठ फ़ील्ड और बाइनरी फ़ाइलों सहित एक ही HTTP अनुरोध के भीतर विभिन्न प्रकार के डेटा के प्रसारण की अनुमति देता है।

एक मल्टीपार्ट अनुरोध में प्रत्येक भाग में शामिल हैं:

• कंटेंट-डिस्पोज़िशन हेडर: फ़ॉर्म फ़ील्ड का नाम (name) निर्दिष्ट करता है और फ़ाइलों के लिए मूल फ़ाइल नाम (filename)।
• कंटेंट-टाइप हेडर: भाग के MIME प्रकार को इंगित करता है (उदाहरण के लिए, text/plain, image/jpeg)।
• बॉडी: उस भाग के लिए वास्तविक डेटा।

फ़ाइल अपलोड के लिए FastAPI का दृष्टिकोण

FastAPI डेटा सत्यापन के लिए पायथन के मानक लाइब्रेरी का लाभ उठाता है और Pydantic के साथ निर्बाध रूप से एकीकृत होता है। फ़ाइल अपलोड के लिए, यह fastapi मॉड्यूल से UploadFile प्रकार का उपयोग करता है। यह क्लास अपलोड की गई फ़ाइल डेटा तक पहुंचने के लिए एक सुविधाजनक और सुरक्षित इंटरफ़ेस प्रदान करता है।

बेसिक फ़ाइल अपलोड कार्यान्वयन

आइए FastAPI में एक एंडपॉइंट बनाने के एक सरल उदाहरण से शुरुआत करें जो एक एकल फ़ाइल अपलोड स्वीकार करता है। हम फ़ाइल पैरामीटर घोषित करने के लिए fastapi से File फ़ंक्शन का उपयोग करेंगे।

            from fastapi import FastAPI, File, UploadFile

app = FastAPI()

@app.post("/files/")
async def create_file(file: UploadFile):
    return {"filename": file.filename, "content_type": file.content_type}

            

              
                Copy
              
            
          

इस उदाहरण में:

• हम FastAPI, File और UploadFile आयात करते हैं।
• एंडपॉइंट /files/ को POST अनुरोध के रूप में परिभाषित किया गया है।
• file पैरामीटर को UploadFile से एनोटेट किया गया है, जो यह दर्शाता है कि यह एक फ़ाइल अपलोड की उम्मीद करता है।
• एंडपॉइंट फ़ंक्शन के अंदर, हम अपलोड की गई फ़ाइल के गुणों जैसे filename और content_type तक पहुंच सकते हैं।

जब कोई क्लाइंट enctype="multipart/form-data" के साथ एक फ़ाइल संलग्न (आमतौर पर एक फ़ॉर्म के माध्यम से) के साथ /files/ पर एक POST अनुरोध भेजता है, तो FastAPI स्वचालित रूप से पार्सिंग को संभाल लेगा और एक UploadFile ऑब्जेक्ट प्रदान करेगा। फिर आप इस ऑब्जेक्ट के साथ इंटरैक्ट कर सकते हैं।

अपलोड की गई फ़ाइलों को सहेजना

अक्सर, आपको अपलोड की गई फ़ाइल को डिस्क पर सहेजना या उसकी सामग्री को संसाधित करना होगा। UploadFile ऑब्जेक्ट इसके लिए तरीके प्रदान करता है:

• read(): फ़ाइल की पूरी सामग्री को बाइट्स के रूप में मेमोरी में पढ़ता है। इसे छोटी फ़ाइलों के लिए उपयोग करें।
• write(content: bytes): फ़ाइल में बाइट्स लिखता है।
• seek(offset: int): वर्तमान फ़ाइल स्थिति को बदलता है।
• close(): फ़ाइल को बंद करता है।

फ़ाइल संचालन को एसिंक्रोनस रूप से संभालना महत्वपूर्ण है, खासकर जब बड़ी फ़ाइलों या I/O-बाउंड कार्यों से निपटना हो। FastAPI का UploadFile एसिंक्रोनस संचालन का समर्थन करता है।

            from fastapi import FastAPI, File, UploadFile
import shutil

app = FastAPI()

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

            

              
                Copy
              
            
          

इस उन्नत उदाहरण में:

• हम यह इंगित करने के लिए File(...) का उपयोग करते हैं कि यह पैरामीटर आवश्यक है।
• हम एक स्थानीय पथ निर्दिष्ट करते हैं जहां फ़ाइल सहेजी जाएगी। सुनिश्चित करें कि uploads निर्देशिका मौजूद है।
• हम बाइनरी राइट मोड (`"wb+"`) में गंतव्य फ़ाइल खोलते हैं।
• हम एसिंक्रोनस रूप से await file.read() का उपयोग करके अपलोड की गई फ़ाइल की सामग्री को पढ़ते हैं और फिर इसे स्थानीय फ़ाइल में लिखते हैं।

ध्यान दें: await file.read() के साथ पूरी फ़ाइल को मेमोरी में पढ़ना बहुत बड़ी फ़ाइलों के लिए समस्याग्रस्त हो सकता है। ऐसे परिदृश्यों के लिए, फ़ाइल सामग्री को स्ट्रीम करने पर विचार करें।

स्ट्रीमिंग फ़ाइल सामग्री

बड़ी फ़ाइलों के लिए, पूरी सामग्री को मेमोरी में पढ़ने से अत्यधिक मेमोरी खपत और संभावित आउट-ऑफ-मेमोरी त्रुटियां हो सकती हैं। अधिक मेमोरी-कुशल दृष्टिकोण फ़ाइल को चंक द्वारा चंक स्ट्रीम करना है। shutil.copyfileobj फ़ंक्शन इसके लिए उत्कृष्ट है, लेकिन हमें इसे एसिंक्रोनस संचालन के लिए अनुकूलित करने की आवश्यकता है।

            from fastapi import FastAPI, File, UploadFile
import aiofiles # Install using: pip install aiofiles

app = FastAPI()

@app.post("/files/stream/")
async def stream_file(file: UploadFile = File(...)):
    file_location = f"./uploads/{file.filename}"
    async with aiofiles.open(file_location, "wb") as out_file:
        content = await file.read()
        await out_file.write(content)
    return {"info": f"file '{file.filename}' streamed and saved at '{file_location}'"}

            

              
                Copy
              
            
          

aiofiles के साथ, हम अपलोड की गई फ़ाइल की सामग्री को एक बार में पूरी फ़ाइल को मेमोरी में लोड किए बिना कुशलतापूर्वक एक गंतव्य फ़ाइल में स्ट्रीम कर सकते हैं। इस संदर्भ में await file.read() अभी भी पूरी फ़ाइल पढ़ता है, लेकिन aiofiles लेखन को अधिक कुशलता से संभालता है। UploadFile के साथ सही चंक-बाय-चंक स्ट्रीमिंग के लिए, आप आमतौर पर await file.read(chunk_size) पर पुनरावृति करेंगे, लेकिन aiofiles.open और await out_file.write(content) सहेजने के लिए एक सामान्य और प्रदर्शनकारी पैटर्न है।

चंकिंग का उपयोग करके एक अधिक स्पष्ट स्ट्रीमिंग दृष्टिकोण:

            from fastapi import FastAPI, File, UploadFile
import aiofiles

app = FastAPI()

CHUNK_SIZE = 1024 * 1024 # 1MB chunk size

@app.post("/files/chunked_stream/")
async def chunked_stream_file(file: UploadFile = File(...)):
    file_location = f"./uploads/{file.filename}"
    async with aiofiles.open(file_location, "wb") as out_file:
        while content := await file.read(CHUNK_SIZE):
            await out_file.write(content)
    return {"info": f"file '{file.filename}' chunked streamed and saved at '{file_location}'"}

            

              
                Copy
              
            
          

यह `chunked_stream_file` एंडपॉइंट फ़ाइल को 1MB के चंक्स में पढ़ता है और प्रत्येक चंक को आउटपुट फ़ाइल में लिखता है। संभावित रूप से बहुत बड़ी फ़ाइलों को संभालने का यह सबसे मेमोरी-कुशल तरीका है।

एकाधिक फ़ाइल अपलोड को संभालना

वेब अनुप्रयोगों को अक्सर उपयोगकर्ताओं को एक साथ कई फ़ाइलें अपलोड करने की आवश्यकता होती है। FastAPI इसे सीधा बनाता है।

फ़ाइलों की सूची अपलोड करना

आप अपने पैरामीटर को UploadFile की सूची के साथ एनोटेट करके फ़ाइलों की एक सूची स्वीकार कर सकते हैं।

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

app = FastAPI()

@app.post("/files/multiple/")
async def create_multiple_files(
    files: List[UploadFile] = File(...)
):
    results = []
    for file in files:
        # Process each file, e.g., save it
        file_location = f"./uploads/{file.filename}"
        with open(file_location, "wb+") as file_object:
            file_object.write(await file.read())
        results.append({"filename": file.filename, "content_type": file.content_type, "saved_at": file_location})
    return {"files_processed": results}

            

              
                Copy
              
            
          

इस परिदृश्य में, क्लाइंट को एक ही फ़ॉर्म फ़ील्ड नाम (उदाहरण के लिए, `files`) के साथ कई भाग भेजने की आवश्यकता होती है। FastAPI उन्हें UploadFile ऑब्जेक्ट की एक पायथन सूची में एकत्र करेगा।

फ़ाइलों और अन्य फ़ॉर्म डेटा को मिलाना

फ़ॉर्म होना आम बात है जिसमें फ़ाइल फ़ील्ड और नियमित टेक्स्ट फ़ील्ड दोनों होते हैं। FastAPI आपको फ़ाइलों के लिए मानक प्रकार एनोटेशन का उपयोग करके अन्य पैरामीटर घोषित करने की अनुमति देकर इसे संभालता है, साथ ही उन फ़ॉर्म फ़ील्ड के लिए Form का उपयोग करता है जो फ़ाइलें नहीं हैं।

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

app = FastAPI()

@app.post("/files/mixed/")
async def upload_mixed_data(
    description: str = Form(...),
    files: List[UploadFile] = File(...) # Accepts multiple files with the name 'files'
):
    results = []
    for file in files:
        # Process each file
        file_location = f"./uploads/{file.filename}"
        with open(file_location, "wb+") as file_object:
            file_object.write(await file.read())
        results.append({"filename": file.filename, "content_type": file.content_type, "saved_at": file_location})
    return {
        "description": description,
        "files_processed": results
    }

            

              
                Copy
              
            
          

Swagger UI या Postman जैसे टूल का उपयोग करते समय, आप description को एक नियमित फ़ॉर्म फ़ील्ड के रूप में निर्दिष्ट करेंगे और फिर files फ़ील्ड के लिए कई भाग जोड़ेंगे, प्रत्येक का कंटेंट टाइप उपयुक्त छवि/दस्तावेज़ प्रकार पर सेट होगा।

उन्नत सुविधाएँ और सर्वोत्तम प्रथाएँ

बुनियादी फ़ाइल हैंडलिंग से परे, मजबूत फ़ाइल अपलोड API बनाने के लिए कई उन्नत सुविधाएँ और सर्वोत्तम प्रथाएँ महत्वपूर्ण हैं।

फ़ाइल आकार सीमा

असीमित फ़ाइल अपलोड की अनुमति देने से सेवा से इनकार करने वाले हमले या अत्यधिक संसाधन खपत हो सकती है। जबकि FastAPI स्वयं डिफ़ॉल्ट रूप से फ्रेमवर्क स्तर पर हार्ड लिमिट लागू नहीं करता है, आपको जांच लागू करनी चाहिए:

• अनुप्रयोग स्तर पर: प्राप्त होने के बाद लेकिन संसाधित या सहेजने से पहले फ़ाइल आकार की जाँच करें।
• वेब सर्वर/प्रॉक्सी स्तर पर: एक निश्चित पेलोड आकार से अधिक के अनुरोधों को अस्वीकार करने के लिए अपने वेब सर्वर (जैसे, Nginx, Uvicorn श्रमिकों के साथ) को कॉन्फ़िगर करें।

अनुप्रयोग-स्तर आकार जांच का उदाहरण:

            from fastapi import FastAPI, File, UploadFile, HTTPException

app = FastAPI()

MAX_FILE_SIZE_MB = 10
MAX_FILE_SIZE_BYTES = MAX_FILE_SIZE_MB * 1024 * 1024

@app.post("/files/limited_size/")
async def upload_with_size_limit(file: UploadFile = File(...)):
    if len(await file.read()) > MAX_FILE_SIZE_BYTES:
        raise HTTPException(status_code=400, detail=f"File is too large. Maximum size is {MAX_FILE_SIZE_MB}MB.")
    
    # Reset file pointer to read content again
    await file.seek(0)
    
    # Proceed with saving or processing the file
    file_location = f"./uploads/{file.filename}"
    with open(file_location, "wb+") as file_object:
        file_object.write(await file.read())
        
    return {"info": f"File '{file.filename}' uploaded successfully."}

            

              
                Copy
              
            
          

महत्वपूर्ण: फ़ाइल के आकार की जाँच करने के लिए इसे पढ़ने के बाद, यदि आप इसकी सामग्री को फिर से पढ़ना चाहते हैं (जैसे, इसे सहेजने के लिए) तो आपको फ़ाइल पॉइंटर को शुरुआत में रीसेट करने के लिए await file.seek(0) का उपयोग करना होगा।

अनुमत फ़ाइल प्रकार (MIME प्रकार)

अपलोड को विशिष्ट फ़ाइल प्रकारों तक सीमित करने से सुरक्षा बढ़ती है और डेटा अखंडता सुनिश्चित होती है। आप UploadFile ऑब्जेक्ट के content_type विशेषता की जाँच कर सकते हैं।

            from fastapi import FastAPI, File, UploadFile, HTTPException

app = FastAPI()

ALLOWED_FILE_TYPES = {"image/jpeg", "image/png", "application/pdf"}

@app.post("/files/restricted_types/")
async def upload_restricted_types(file: UploadFile = File(...)):
    if file.content_type not in ALLOWED_FILE_TYPES:
        raise HTTPException(status_code=400, detail=f"Unsupported file type: {file.content_type}. Allowed types are: {', '.join(ALLOWED_FILE_TYPES)}")
        
    # Proceed with saving or processing the file
    file_location = f"./uploads/{file.filename}"
    with open(file_location, "wb+") as file_object:
        file_object.write(await file.read())
        
    return {"info": f"File '{file.filename}' uploaded successfully and is of an allowed type."}

            

              
                Copy
              
            
          

अधिक मजबूत प्रकार की जाँच के लिए, विशेष रूप से छवियों के लिए, आप फ़ाइल की वास्तविक सामग्री का निरीक्षण करने के लिए Pillow जैसी लाइब्रेरी का उपयोग करने पर विचार कर सकते हैं, क्योंकि MIME प्रकारों को कभी-कभी स्पूफ किया जा सकता है।

त्रुटि प्रबंधन और उपयोगकर्ता प्रतिक्रिया

उपयोगकर्ता को स्पष्ट और कार्रवाई योग्य त्रुटि संदेश प्रदान करें। मानक HTTP त्रुटि प्रतिक्रियाओं के लिए FastAPI के HTTPException का उपयोग करें।

• फ़ाइल नहीं मिली/गायब: यदि कोई आवश्यक फ़ाइल पैरामीटर नहीं भेजा गया है।
• फ़ाइल का आकार पार हो गया: जैसा कि आकार सीमा उदाहरण में दिखाया गया है।
• अमान्य फ़ाइल प्रकार: जैसा कि प्रकार प्रतिबंध उदाहरण में दिखाया गया है।
• सर्वर त्रुटियाँ: फ़ाइल को सहेजने या संसाधित करने के दौरान समस्याओं के लिए (उदाहरण के लिए, डिस्क फुल, अनुमति त्रुटियाँ)।

सुरक्षा विचार

फ़ाइल अपलोड सुरक्षा जोखिम पेश करते हैं:

• दुर्भावनापूर्ण फ़ाइलें: निष्पादन योग्य फ़ाइलें (.exe, .sh) या स्क्रिप्ट अपलोड करना जो अन्य फ़ाइल प्रकारों के रूप में प्रच्छन्न हैं। हमेशा फ़ाइल प्रकारों को मान्य करें और अपलोड की गई फ़ाइलों को मैलवेयर के लिए स्कैन करने पर विचार करें।
• पथ ट्रैवर्सल: हमलावरों को अनपेक्षित निर्देशिकाओं में फ़ाइलें अपलोड करने से रोकने के लिए फ़ाइल नामों को सैनिटाइज़ करें (उदाहरण के लिए, ../../etc/passwd जैसे फ़ाइल नामों का उपयोग करके)। FastAPI का UploadFile बुनियादी फ़ाइल नाम सैनिटाइजेशन को संभालता है, लेकिन अतिरिक्त सावधानी बुद्धिमानी है।
• सेवा से इनकार: फ़ाइल आकार सीमा लागू करें और संभावित रूप से अपलोड एंडपॉइंट पर दर सीमित करें।
• क्रॉस-साइट स्क्रिप्टिंग (XSS): यदि आप फ़ाइल नामों या फ़ाइल सामग्री को सीधे किसी वेब पेज पर प्रदर्शित करते हैं, तो सुनिश्चित करें कि उन्हें XSS हमलों को रोकने के लिए ठीक से एस्केप किया गया है।

सर्वोत्तम अभ्यास: अपलोड की गई फ़ाइलों को अपने वेब सर्वर के दस्तावेज़ रूट के बाहर संग्रहीत करें, और उन्हें उचित एक्सेस नियंत्रण के साथ एक समर्पित एंडपॉइंट के माध्यम से परोसें, या एक कंटेंट डिलीवरी नेटवर्क (CDN) का उपयोग करें।

फ़ाइल अपलोड के साथ Pydantic मॉडल का उपयोग करना

जबकि फ़ाइलों के लिए UploadFile प्राथमिक प्रकार है, आप अधिक जटिल डेटा संरचनाओं के लिए फ़ाइल अपलोड को Pydantic मॉडल में एकीकृत कर सकते हैं। हालांकि, मल्टीपार्ट फॉर्म के लिए मानक Pydantic मॉडल के भीतर प्रत्यक्ष फ़ाइल अपलोड फ़ील्ड मूल रूप से समर्थित नहीं हैं। इसके बजाय, आप आमतौर पर फ़ाइल को एक अलग पैरामीटर के रूप में प्राप्त करते हैं और फिर संभावित रूप से इसे एक ऐसे प्रारूप में संसाधित करते हैं जिसे Pydantic मॉडल द्वारा संग्रहीत या मान्य किया जा सकता है।

एक सामान्य पैटर्न मेटाडेटा के लिए एक Pydantic मॉडल रखना और फिर फ़ाइल को अलग से प्राप्त करना है:

            from fastapi import FastAPI, File, UploadFile, Form
from pydantic import BaseModel
from typing import Optional

class UploadMetadata(BaseModel):
    title: str
    description: Optional[str] = None

app = FastAPI()

@app.post("/files/model_metadata/")
async def upload_with_metadata(
    metadata: str = Form(...), # Receive metadata as a JSON string
    file: UploadFile = File(...)
):
    import json
    try:
        metadata_obj = UploadMetadata(**json.loads(metadata))
    except json.JSONDecodeError:
        raise HTTPException(status_code=400, detail="Invalid JSON format for metadata")
    except Exception as e:
        raise HTTPException(status_code=400, detail=f"Error parsing metadata: {e}")

    # Now you have metadata_obj and file
    # Proceed with saving file and using metadata
    file_location = f"./uploads/{file.filename}"
    with open(file_location, "wb+") as file_object:
        file_object.write(await file.read())

    return {
        "message": "File uploaded successfully with metadata",
        "metadata": metadata_obj,
        "filename": file.filename
    }

            

              
                Copy
              
            
          

इस पैटर्न में, क्लाइंट मेटाडेटा को एक फ़ॉर्म फ़ील्ड (जैसे, metadata) के भीतर एक JSON स्ट्रिंग के रूप में और फ़ाइल को एक अलग मल्टीपार्ट भाग के रूप में भेजता है। सर्वर तब JSON स्ट्रिंग को एक Pydantic ऑब्जेक्ट में पार्स करता है।

बड़ी फ़ाइल अपलोड और चंकिंग

बहुत बड़ी फ़ाइलों (उदाहरण के लिए, गीगाबाइट) के लिए, स्ट्रीमिंग भी वेब सर्वर या क्लाइंट-साइड सीमाओं को हिट कर सकती है। एक अधिक उन्नत तकनीक चंक्ड अपलोड है, जहां क्लाइंट फ़ाइल को छोटे टुकड़ों में तोड़ता है और उन्हें क्रमिक रूप से या समानांतर में अपलोड करता है। सर्वर तब इन चंक्स को फिर से जोड़ता है। इसके लिए आम तौर पर कस्टम क्लाइंट-साइड लॉजिक और चंक प्रबंधन को संभालने के लिए डिज़ाइन किए गए सर्वर एंडपॉइंट की आवश्यकता होती है (उदाहरण के लिए, चंक्स की पहचान करना, अस्थायी भंडारण और अंतिम असेंबली)।

जबकि FastAPI क्लाइंट-इनिशिएटेड चंक्ड अपलोड के लिए अंतर्निहित समर्थन प्रदान नहीं करता है, आप इस लॉजिक को अपने FastAPI एंडपॉइंट के भीतर लागू कर सकते हैं। इसमें ऐसे एंडपॉइंट बनाना शामिल है जो:

• अलग-अलग फ़ाइल चंक्स प्राप्त करें।
• इन चंक्स को अस्थायी रूप से संग्रहीत करें, संभवतः उनके क्रम और चंक्स की कुल संख्या का संकेत देने वाले मेटाडेटा के साथ।
• यह संकेत देने के लिए एक एंडपॉइंट या तंत्र प्रदान करें कि सभी चंक्स अपलोड किए गए हैं, जो पुन: असेंबली प्रक्रिया को ट्रिगर करता है।

यह एक अधिक जटिल उपक्रम है और इसमें अक्सर क्लाइंट साइड पर जावास्क्रिप्ट लाइब्रेरी शामिल होती हैं।

अंतर्राष्ट्रीयकरण और वैश्वीकरण संबंधी विचार

वैश्विक दर्शकों के लिए API बनाते समय, फ़ाइल अपलोड को विशेष ध्यान देने की आवश्यकता होती है:

• फ़ाइल नाम: दुनिया भर के उपयोगकर्ता फ़ाइल नामों में गैर-ASCII वर्णों का उपयोग कर सकते हैं (उदाहरण के लिए, लहजे, आइडियोग्राम)। सुनिश्चित करें कि आपका सिस्टम इन फ़ाइल नामों को सही ढंग से संभालता और संग्रहीत करता है। UTF-8 एन्कोडिंग आम तौर पर मानक है, लेकिन गहरी अनुकूलता के लिए सावधानीपूर्वक एन्कोडिंग/डिकोडिंग और सैनिटाइजेशन की आवश्यकता हो सकती है।
• फ़ाइल आकार इकाइयाँ: जबकि MB और GB आम हैं, इस बात का ध्यान रखें कि उपयोगकर्ता फ़ाइल आकार को कैसे देखते हैं। उपयोगकर्ता के अनुकूल तरीके से सीमाएँ प्रदर्शित करना महत्वपूर्ण है।
• कंटेंट प्रकार: उपयोगकर्ता कम सामान्य MIME प्रकारों वाली फ़ाइलें अपलोड कर सकते हैं। सुनिश्चित करें कि आपकी अनुमत प्रकारों की सूची व्यापक है या आपके उपयोग के मामले के लिए पर्याप्त लचीली है।
• क्षेत्रीय विनियम: विभिन्न देशों में डेटा निवास कानूनों और विनियमों से अवगत रहें। अपलोड की गई फ़ाइलों को संग्रहीत करने के लिए इन नियमों का अनुपालन आवश्यक हो सकता है।
• उपयोगकर्ता इंटरफ़ेस: फ़ाइलों को अपलोड करने के लिए क्लाइंट-साइड इंटरफ़ेस सहज होना चाहिए और उपयोगकर्ता की भाषा और लोकेल का समर्थन करना चाहिए।

परीक्षण के लिए उपकरण और लाइब्रेरी

फ़ाइल अपलोड एंडपॉइंट का परीक्षण महत्वपूर्ण है। यहां कुछ सामान्य उपकरण दिए गए हैं:

• Swagger UI (इंटरएक्टिव API डॉक्स): FastAPI स्वचालित रूप से Swagger UI दस्तावेज़ उत्पन्न करता है। आप सीधे ब्राउज़र इंटरफ़ेस से फ़ाइल अपलोड का परीक्षण कर सकते हैं। फ़ाइल इनपुट फ़ील्ड देखें और "फ़ाइल चुनें" बटन पर क्लिक करें।
• Postman: एक लोकप्रिय API विकास और परीक्षण उपकरण। फ़ाइल अपलोड अनुरोध भेजने के लिए:
• अनुरोध विधि को POST पर सेट करें।
• अपने API एंडपॉइंट URL दर्ज करें।
• "बॉडी" टैब पर जाएं।
• प्रकार के रूप में "फॉर्म-डेटा" का चयन करें।
• कुंजी-मान जोड़े में, अपने फ़ाइल पैरामीटर का नाम दर्ज करें (उदाहरण के लिए, file)।
• प्रकार को "टेक्स्ट" से "फ़ाइल" में बदलें।
• अपने स्थानीय सिस्टम से एक फ़ाइल का चयन करने के लिए "फ़ाइलें चुनें" पर क्लिक करें।
• यदि आपके पास अन्य फ़ॉर्म फ़ील्ड हैं, तो उन्हें समान रूप से जोड़ें, उनका प्रकार "टेक्स्ट" रखें।
• अनुरोध भेजें।
• cURL: HTTP अनुरोध करने के लिए एक कमांड-लाइन टूल।
• एकल फ़ाइल के लिए: curl -X POST -F "file=@/path/to/your/local/file.txt" http://localhost:8000/files/
• एकाधिक फ़ाइलों के लिए: curl -X POST -F "files=@/path/to/file1.txt" -F "files=@/path/to/file2.png" http://localhost:8000/files/multiple/
• मिश्रित डेटा के लिए: curl -X POST -F "description=My description" -F "files=@/path/to/file.txt" http://localhost:8000/files/mixed/
• पायथन की `requests` लाइब्रेरी: प्रोग्रामेटिक परीक्षण के लिए।

            import requests

url = "http://localhost:8000/files/save/"
files = {'file': open('/path/to/your/local/file.txt', 'rb')}

response = requests.post(url, files=files)
print(response.json())

# For multiple files
url_multiple = "http://localhost:8000/files/multiple/"
files_multiple = {
    'files': [('file1.txt', open('/path/to/file1.txt', 'rb')),
              ('image.png', open('/path/to/image.png', 'rb'))]
}
response_multiple = requests.post(url_multiple, files=files_multiple)
print(response_multiple.json())

# For mixed data
url_mixed = "http://localhost:8000/files/mixed/"
data = {'description': 'Test description'}
files_mixed = {'files': open('/path/to/another_file.txt', 'rb')}
response_mixed = requests.post(url_mixed, data=data, files=files_mixed)
print(response_mixed.json())

            

              
                Copy
              
            
          

निष्कर्ष

FastAPI मल्टीपार्ट फ़ाइल अपलोड को संभालने का एक शक्तिशाली, कुशल और सहज तरीका प्रदान करता है। UploadFile प्रकार और एसिंक्रोनस प्रोग्रामिंग का लाभ उठाकर, डेवलपर्स मजबूत API बना सकते हैं जो फ़ाइल हैंडलिंग क्षमताओं को निर्बाध रूप से एकीकृत करते हैं। सुरक्षा को प्राथमिकता देना, उपयुक्त त्रुटि प्रबंधन लागू करना और फ़ाइल नाम एन्कोडिंग और नियामक अनुपालन जैसे पहलुओं को संबोधित करके एक वैश्विक उपयोगकर्ता आधार की आवश्यकताओं पर विचार करना याद रखें।

चाहे आप एक साधारण छवि साझाकरण सेवा या एक जटिल दस्तावेज़ प्रसंस्करण प्लेटफ़ॉर्म बना रहे हों, FastAPI की फ़ाइल अपलोड सुविधाओं में महारत हासिल करना एक महत्वपूर्ण संपत्ति होगी। इसकी क्षमताओं का पता लगाना जारी रखें, सर्वोत्तम प्रथाओं को लागू करें और अपने अंतर्राष्ट्रीय दर्शकों के लिए असाधारण उपयोगकर्ता अनुभव प्रदान करें।