FastAPI ફાઇલ અપલોડ્સમાં નિપુણતા: મલ્ટિપાર્ટ ફોર્મ પ્રોસેસિંગમાં ઊંડાણપૂર્વકનો અભ્યાસ

આધુનિક વેબ એપ્લિકેશન્સમાં, ફાઇલ અપલોડને હેન્ડલ કરવાની ક્ષમતા એ મૂળભૂત જરૂરિયાત છે. ભલે તે વપરાશકર્તાઓ પ્રોફાઇલ ચિત્રો સબમિટ કરતા હોય, પ્રોસેસિંગ માટે દસ્તાવેજો, અથવા શેરિંગ માટે મીડિયા, મજબૂત અને કાર્યક્ષમ ફાઇલ અપલોડ મિકેનિઝમ્સ નિર્ણાયક છે. FastAPI, એક ઉચ્ચ-પ્રદર્શન પાઇથન વેબ ફ્રેમવર્ક, આ ક્ષેત્રમાં શ્રેષ્ઠ છે, જે મલ્ટિપાર્ટ ફોર્મ ડેટાનું સંચાલન કરવાની સુવ્યવસ્થિત રીતો પ્રદાન કરે છે, જે HTTP પર ફાઇલો મોકલવા માટેનું માનક છે. આ વ્યાપક માર્ગદર્શિકા તમને FastAPI ફાઇલ અપલોડની જટિલતાઓમાંથી પસાર કરશે, મૂળભૂત અમલીકરણથી લઈને અદ્યતન વિચારણાઓ સુધી, જેથી તમે વૈશ્વિક પ્રેક્ષકો માટે શક્તિશાળી અને સ્કેલેબલ APIs વિશ્વાસપૂર્વક બનાવી શકો.

મલ્ટિપાર્ટ ફોર્મ ડેટાને સમજવું

FastAPI ના અમલીકરણમાં ડૂબકી મારતા પહેલા, મલ્ટિપાર્ટ ફોર્મ ડેટા શું છે તે સમજવું આવશ્યક છે. જ્યારે વેબ બ્રાઉઝર ફાઇલો ધરાવતું ફોર્મ સબમિટ કરે છે, ત્યારે તે સામાન્ય રીતે enctype="multipart/form-data" એટ્રિબ્યુટનો ઉપયોગ કરે છે. આ એન્કોડિંગ પ્રકાર ફોર્મ સબમિશનને બહુવિધ ભાગોમાં તોડી નાખે છે, દરેકની પોતાની સામગ્રી પ્રકાર અને ડિસ્પોઝિશન માહિતી હોય છે. આ એક જ HTTP વિનંતીમાં વિવિધ પ્રકારના ડેટાના પ્રસારણને મંજૂરી આપે છે, જેમાં ટેક્સ્ટ ફીલ્ડ્સ, નોન-ટેક્સ્ટ ફીલ્ડ્સ અને બાઈનરી ફાઇલોનો સમાવેશ થાય છે.

મલ્ટિપાર્ટ વિનંતીના દરેક ભાગમાં આનો સમાવેશ થાય છે:

• Content-Disposition Header: ફોર્મ ફીલ્ડનું નામ (name) અને, ફાઇલો માટે, મૂળ ફાઇલનામ (filename) સ્પષ્ટ કરે છે.
• Content-Type Header: ભાગના MIME પ્રકારને સૂચવે છે (દા.ત., text/plain, image/jpeg).
• Body: તે ભાગ માટેનો વાસ્તવિક ડેટા.

ફાઇલ અપલોડ માટે FastAPI નો અભિગમ

FastAPI Python ની સ્ટાન્ડર્ડ લાઇબ્રેરીનો લાભ લે છે અને ડેટા વેલિડેશન માટે 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 ને એક્સેસ કરી શકીએ છીએ.

જ્યારે કોઈ ક્લાયન્ટ /files/ પર એક ફાઇલ સાથે POST વિનંતી મોકલે છે (સામાન્ય રીતે enctype="multipart/form-data" વાળા ફોર્મ દ્વારા), 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 ઓબ્જેક્ટ્સની Python સૂચિમાં એકત્રિત કરશે.

ફાઇલો અને અન્ય ફોર્મ ડેટાનું મિશ્રણ

ફાઇલ ફીલ્ડ્સ અને નિયમિત ટેક્સ્ટ ફીલ્ડ્સ બંને ધરાવતા ફોર્મ્સ હોવા સામાન્ય છે. 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 ફીલ્ડ માટે બહુવિધ ભાગો ઉમેરશો, દરેકનો કન્ટેન્ટ પ્રકાર યોગ્ય ઇમેજ/દસ્તાવેજ પ્રકાર પર સેટ કરેલો હશે.

અદ્યતન સુવિધાઓ અને શ્રેષ્ઠ પદ્ધતિઓ

મૂળભૂત ફાઇલ હેન્ડલિંગ ઉપરાંત, મજબૂત ફાઇલ અપલોડ APIs બનાવવા માટે ઘણી અદ્યતન સુવિધાઓ અને શ્રેષ્ઠ પદ્ધતિઓ નિર્ણાયક છે.

ફાઇલ કદ મર્યાદાઓ

અમર્યાદિત ફાઇલ અપલોડને મંજૂરી આપવાથી ડિનાયલ-ઓફ-સર્વિસ હુમલાઓ અથવા વધુ પડતા સંસાધન વપરાશ થઈ શકે છે. જ્યારે FastAPI પોતે ફ્રેમવર્ક સ્તરે ડિફોલ્ટ રૂપે સખત મર્યાદાઓ લાગુ કરતું નથી, ત્યારે તમારે તપાસ અમલમાં મૂકવી જોઈએ:

• એપ્લિકેશન સ્તરે: ફાઇલ પ્રાપ્ત થયા પછી પરંતુ પ્રક્રિયા અથવા સાચવતા પહેલા ફાઇલનું કદ તપાસો.
• વેબ સર્વર/પ્રોક્સી સ્તરે: ચોક્કસ પેલોડ કદ કરતાં વધુની વિનંતીઓને નકારવા માટે તમારા વેબ સર્વર (દા.ત., Nginx, Uvicorn with workers) ને રૂપરેખાંકિત કરો.

એપ્લિકેશન-સ્તરના કદ તપાસનું ઉદાહરણ:

            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 એન્ડપોઇન્ટ્સમાં લાગુ કરી શકો છો. આમાં એવા એન્ડપોઇન્ટ્સ બનાવવાનો સમાવેશ થાય છે જે:

• વ્યક્તિગત ફાઇલ ચંક્સ પ્રાપ્ત કરે છે.
• આ ચંક્સને અસ્થાયી રૂપે સ્ટોર કરે છે, સંભવતઃ તેમના ક્રમ અને ચંક્સની કુલ સંખ્યા દર્શાવતા મેટાડેટા સાથે.
• જ્યારે બધા ચંક્સ અપલોડ થઈ જાય ત્યારે સંકેત આપવા માટે એન્ડપોઇન્ટ અથવા મિકેનિઝમ પ્રદાન કરે છે, જે પુનઃએસેમ્બલી પ્રક્રિયાને ટ્રિગર કરે છે.

આ એક વધુ જટિલ ઉપક્રમ છે અને તેમાં ઘણીવાર ક્લાયન્ટ બાજુ પર JavaScript લાઇબ્રેરીઓનો સમાવેશ થાય છે.

આંતરરાષ્ટ્રીયકરણ અને વૈશ્વિકરણની વિચારણાઓ

વૈશ્વિક પ્રેક્ષકો માટે APIs બનાવતી વખતે, ફાઇલ અપલોડ્સ પર વિશેષ ધ્યાન આપવાની જરૂર છે:

• ફાઇલનામો: વિશ્વભરના વપરાશકર્તાઓ ફાઇલનામોમાં નોન-ASCII અક્ષરો (દા.ત., એક્સેન્ટ્સ, આઇડિયોગ્રામ્સ) નો ઉપયોગ કરી શકે છે. ખાતરી કરો કે તમારી સિસ્ટમ આ ફાઇલનામોને યોગ્ય રીતે હેન્ડલ કરે છે અને સ્ટોર કરે છે. UTF-8 એન્કોડિંગ સામાન્ય રીતે પ્રમાણભૂત છે, પરંતુ ઊંડી સુસંગતતા માટે કાળજીપૂર્વક એન્કોડિંગ/ડિકોડિંગ અને સેનિટાઇઝેશનની જરૂર પડી શકે છે.
• ફાઇલ કદના એકમો: જ્યારે MB અને GB સામાન્ય છે, ત્યારે વપરાશકર્તાઓ ફાઇલના કદને કેવી રીતે સમજે છે તે ધ્યાનમાં રાખો. વપરાશકર્તા-મૈત્રીપૂર્ણ રીતે મર્યાદાઓ પ્રદર્શિત કરવી મહત્વપૂર્ણ છે.
• કન્ટેન્ટ પ્રકારો: વપરાશકર્તાઓ ઓછા સામાન્ય MIME પ્રકારોવાળી ફાઇલો અપલોડ કરી શકે છે. ખાતરી કરો કે તમારી મંજૂર પ્રકારોની સૂચિ તમારા ઉપયોગના કેસ માટે વ્યાપક અથવા પર્યાપ્ત લવચીક છે.
• પ્રાદેશિક નિયમો: વિવિધ દેશોમાં ડેટા રેસિડેન્સી કાયદાઓ અને નિયમોથી વાકેફ રહો. અપલોડ કરેલી ફાઇલોને સંગ્રહિત કરવા માટે આ નિયમોનું પાલન કરવું જરૂરી હોઈ શકે છે.
• વપરાશકર્તા ઈન્ટરફેસ: ફાઇલો અપલોડ કરવા માટે ક્લાયન્ટ-સાઇડ ઇન્ટરફેસ સાહજિક હોવું જોઈએ અને વપરાશકર્તાની ભાષા અને લોકેલને સમર્થન આપવું જોઈએ.

પરીક્ષણ માટે સાધનો અને લાઇબ્રેરીઓ

ફાઇલ અપલોડ એન્ડપોઇન્ટ્સનું પરીક્ષણ કરવું નિર્ણાયક છે. અહીં કેટલાક સામાન્ય સાધનો છે:

• Swagger UI (Interactive API Docs): FastAPI આપમેળે Swagger UI દસ્તાવેજીકરણ જનરેટ કરે છે. તમે બ્રાઉઝર ઇન્ટરફેસથી સીધા ફાઇલ અપલોડનું પરીક્ષણ કરી શકો છો. ફાઇલ ઇનપુટ ફીલ્ડ શોધો અને "Choose File" બટન પર ક્લિક કરો.
• Postman: એક લોકપ્રિય API વિકાસ અને પરીક્ષણ સાધન. ફાઇલ અપલોડ વિનંતી મોકલવા માટે:
• વિનંતી પદ્ધતિને POST પર સેટ કરો.
• તમારો API એન્ડપોઇન્ટ URL દાખલ કરો.
• "Body" ટેબ પર જાઓ.
• પ્રકાર તરીકે "form-data" પસંદ કરો.
• કી-વેલ્યુ જોડીમાં, તમારા ફાઇલ પેરામીટરનું નામ દાખલ કરો (દા.ત., file).
• પ્રકારને "Text" થી "File" માં બદલો.
• તમારી સ્થાનિક સિસ્ટમમાંથી ફાઇલ પસંદ કરવા માટે "Choose Files" પર ક્લિક કરો.
• જો તમારી પાસે અન્ય ફોર્મ ફીલ્ડ્સ હોય, તો તેમને સમાન રીતે ઉમેરો, તેમના પ્રકારને "Text" તરીકે રાખીને.
• વિનંતી મોકલો.
• 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/
• Python's `requests` library: પ્રોગ્રામેટિક પરીક્ષણ માટે.

            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 પ્રકાર અને અસિંક્રોનસ પ્રોગ્રામિંગનો લાભ લઈને, ડેવલપર્સ મજબૂત APIs બનાવી શકે છે જે ફાઇલ હેન્ડલિંગ ક્ષમતાઓને એકીકૃત રીતે સંકલિત કરે છે. સુરક્ષાને પ્રાથમિકતા આપવાનું યાદ રાખો, યોગ્ય ભૂલ સંભાળવાનો અમલ કરો, અને ફાઇલનામ એન્કોડિંગ અને નિયમનકારી પાલન જેવા પાસાઓને સંબોધીને વૈશ્વિક વપરાશકર્તા આધારની જરૂરિયાતોને ધ્યાનમાં લો.

ભલે તમે એક સરળ ઇમેજ શેરિંગ સેવા બનાવી રહ્યા હોવ અથવા જટિલ દસ્તાવેજ પ્રોસેસિંગ પ્લેટફોર્મ, FastAPI ની ફાઇલ અપલોડ સુવિધાઓમાં નિપુણતા મેળવવી એ એક નોંધપાત્ર સંપત્તિ હશે. તેની ક્ષમતાઓનું અન્વેષણ કરવાનું ચાલુ રાખો, શ્રેષ્ઠ પદ્ધતિઓનો અમલ કરો અને તમારા આંતરરાષ્ટ્રીય પ્રેક્ષકો માટે અસાધારણ વપરાશકર્તા અનુભવો પ્રદાન કરો.