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 போன்ற பண்புகளை நாம் அணுகலாம்.

ஒரு கிளையண்ட் /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 பொருட்களின் பைதான் பட்டியலில் சேகரிக்கும்.

கோப்புகள் மற்றும் பிற படிவத் தரவைக் கலத்தல்

கோப்பு புலங்கள் மற்றும் வழக்கமான உரை புலங்கள் இரண்டையும் கொண்ட படிவங்கள் இருப்பது பொதுவானது. கோப்புகளாக இல்லாத படிவ புலங்களுக்கு Form உடன் நிலையான வகை சிறுகுறிப்புகளைப் பயன்படுத்தி பிற அளவுருக்களை அறிவிக்க FastAPI இதை கையாளுகிறது.

            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
              
            
          

மிகவும் வலுவான வகை சரிபார்ப்புக்கு, குறிப்பாக படங்களுக்கு, MIME வகைகள் சில நேரங்களில் ஏமாற்றப்படக்கூடும் என்பதால், பைல்லின் உண்மையான உள்ளடக்கத்தை ஆய்வு செய்ய Pillow போன்ற நூலகங்களைப் பயன்படுத்துவதைக் கவனியுங்கள்.

பிழை கையாளுதல் மற்றும் பயனர் பின்னூட்டம்

பயனருக்கு தெளிவான மற்றும் செயல்படக்கூடிய பிழை செய்திகளை வழங்கவும். நிலையான 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 இன் கோப்பு பதிவேற்ற அம்சங்களில் தேர்ச்சி பெறுவது ஒரு குறிப்பிடத்தக்க சொத்தாக இருக்கும். அதன் திறன்களை ஆராய்வதைத் தொடருங்கள், சிறந்த நடைமுறைகளைச் செயல்படுத்தி, உங்கள் சர்வதேச பார்வையாளர்களுக்கு விதிவிலக்கான பயனர் அனுபவங்களை வழங்குங்கள்.