તમે ભૂલો અને HTTP અપવાદો કેવી રીતે સંભાળો છો?

Question

Accepted Answer

FastAPI **અપવાદો ઉત્થાપિત** કરીને ભૂલોનો સામનો કરે છે જે તેને યોગ્ય HTTP પ્રતિક્રિયામાં રૂપાંતરિત કરે છે. `HTTPException` મોટાભાગના કેસોને આવરી લે છે; કસ્ટમ અપવાદ હેન્ડલર્સ તમને વૈશ્વિક સ્તરે ભૂલ ફોર્મેટિંગ નિયંત્રિત કરવા દે છે.

## HTTPException ઉત્થાપિત કરવું

```python
from fastapi import HTTPException

@app.get("/items/{id}")
def get_item(id: int):
    item = db.get(id)
    if not item:
        raise HTTPException(status_code=404, detail="Item not found")   # → 404 JSON response
    if not item.is_public:
        raise HTTPException(status_code=403, detail="Forbidden")
    return item
```

`raise HTTPException(status_code=..., detail=...)` એ ભૂલ પરત કરવાનો રૂઢિચાર માર્ગ છે — FastAPI આપેલ સ્થિતિ સાથે JSON પ્રતિક્રિયા `{"detail": "..."}` બનાવે છે. `detail` કોઈપણ JSON-સીરીયલાઈઝેબલ મૂલ્ય હોઈ શકે છે (સ્ટ્રિંગ, dict, સૂચી).

## ની માન્યતા ભૂલો સ્વચાલિત છે (422)

```text
When request data fails Pydantic validation, FastAPI AUTOMATICALLY returns a 422
with a structured list of exactly which fields are wrong — you write nothing.
```

## કસ્ટમ અપવાદ હેન્ડલર્સ (વૈશ્વિક ફોર્મેટિંગ)

```python
from fastapi import Request
from fastapi.responses import JSONResponse

class ItemNotFound(Exception):
    def __init__(self, item_id: int): self.item_id = item_id

@app.exception_handler(ItemNotFound)         # handle a custom exception type globally
def handle_not_found(request: Request, exc: ItemNotFound):
    return JSONResponse(status_code=404, content={"error": f"Item {exc.item_id} not found"})

@app.get("/items/{id}")
def get(id: int):
    raise ItemNotFound(id)        # raise your domain exception; the handler formats it
```

કસ્ટમ અપવાદ હેન્ડલર્સ તમને તમારા પોતાના (ડોમેઇન) અપવાદોને પ્રતિક્રિયાઓ સાથે મેપ કરવા દે છે, ભૂલ ફોર્મેટિંગને કેન્દ્રીકૃત કરે છે અને હેન્ડલર કોડ સ્વચ્છ રાખે છે.

## ડિફોલ્ટ હેન્ડલર્સ ઓવररાઈડ કરવું

```python
from fastapi.exceptions import RequestValidationError

@app.exception_handler(RequestValidationError)   # customize the 422 validation-error format
def validation_handler(request, exc):
    return JSONResponse(status_code=422, content={"errors": exc.errors()})
```

## તે શા માટે મહત્વપૂર્ણ છે

નિર્ભરযોગ્ય, વ્યાવસાયિક APIs બનાવવા માટે યોગ્ય ભૂલ સંભાલ આવશ્યક છે, અને FastAPI નો અભિગમ સ્વચ્છ અને સુસંગત છે.

રૂઢિચાર `HTTPException` યોગ્ય ભૂલ પ્રતિક્રિયાઓ યોગ્ય સ્થિતિ કોડ અને સંદેશ સાથે પરત કરવું સરળ બનાવે છે — કોઈપણ એન્ડપોઇન્ટ માટે મૂળભૂત જે નિષ્ફળ હોઈ શકે છે (મળ્યું નહીં, પ્રતિબંધિત, ખરાબ સ્થિતિ).

તેટલું જ મૂલ્યવાન છે કે **માન્યતા ભૂલો આપોઆપ સંભાળવામાં આવે છે** (Pydantic નિષ્ફળતાઓ તમારી બાજુ કોઈ કોડ વિના માળખાબદ્ધ 422 પ્રતિક્રિયાઓ ઉત્પન્ન કરે છે), અને તે **કસ્ટમ અપવાદ હેન્ડલર્સ** તમને તમારા પોતાના ડોમેઇન અપવાદોને પ્રતિક્રિયાઓ સાથે મેપ કરવા અને સમગ્ર API માટે સુસંગત ભૂલ ફોર્મેટ લાગુ કરવાનું દ્વારા આપે છે — બંને જાળવણીયોગ્યતા (કેન્દ્રીકૃત ભૂલ તર્કશાસ્ત્ર) અને ક્લાયન્ટ અનુભવ (આગાહીપૂર્વક ભૂલ આકૃતિઓ) સુધારે છે.

`HTTPException`, આપોઆપ માન્યતા ભૂલો, અને કસ્ટમ હેન્ડલર્સને સમજવું ભૂલ સંભાલણાના વ્યવહારિક સ્પેક્ટ્રમને આવરી લે છે, તેને મજબૂત APIs બનાવવા માટે મહત્વપૂર્ણ જ્ઞાન બનાવે છે.