Errors-ஐ எவ்வாறு கையாள்வது மற்றும் HTTP exceptions-ஐ எவ்வாறு எழுப்புவது?

Question

Accepted Answer

FastAPI errors-ஐ **exceptions எழுப்புவதன்** மூலம் கையாளுகிறது, அவற்றை சரியான HTTP responses-ஆக மாற்றுகிறது. `HTTPException` பெரும்பாலான வழக்குகளை உள்ளடக்குகிறது; custom exception handlers உங்களை error formatting-ஐ globally கட்டுப்படுத்த அனுமதிக்கின்றன.

## 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=...)` ஒரு error-ஐ return செய்யும் idiomatic வழியாகும் — FastAPI கொடுக்கப்பட்ட status-உடன் `{"detail": "..."}` என்ற JSON response-ஐ உருவாக்குகிறது. `detail` எந்த JSON-serializable மதிப்பாகவும் இருக்கலாம் (string, dict, list).

## Validation errors தானியங்கி (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.
```

## Custom exception handlers (global formatting)

```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
```

Custom exception handlers உங்கள் சொந்த (domain) exceptions-ஐ responses-உடன் map செய்ய அனுமதிக்கின்றன, error formatting-ஐ மையப்படுத்தி handler code-ஐ சுத்தமாக வைத்திருக்கின்றன.

## Default handlers-ஐ override செய்தல்

```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()})
```

## இது ஏன் முக்கியம்

சரியான error handling நம்பகமான, தொழில்முறை APIs-ஐ உருவாக்குவதற்கு அவசியமானது, மேலும் FastAPI-இன் அணுகுமுறை சுத்தமாகவும் சீராகவும் உள்ளது.

idiomatic `HTTPException` பொருத்தமான status codes மற்றும் messages-உடன் சரியான error responses-ஐ return செய்வதை எளிதாக்குகிறது — தோல்வியடையக்கூடிய எந்த endpoint-க்கும் அடிப்படையானது (not found, forbidden, bad state).

அதே அளவு மதிப்புமிக்கது என்னவென்றால் **validation errors தானாகவே கையாளப்படுகின்றன** (Pydantic தோல்விகள் உங்களிடமிருந்து எந்த code-ம் இல்லாமல் structured 422 responses-ஐ உருவாக்குகின்றன), மேலும் **custom exception handlers** உங்கள் சொந்த domain exceptions-ஐ responses-உடன் map செய்து முழு API முழுவதும் சீரான error format-ஐ அமல்படுத்த அனுமதிக்கின்றன — maintainability (மையப்படுத்தப்பட்ட error logic) மற்றும் client experience (கணிக்கக்கூடிய error வடிவங்கள்) ஆகிய இரண்டையும் மேம்படுத்துகின்றன.

`HTTPException`, தானியங்கி validation errors, மற்றும் custom handlers ஆகியவற்றைப் புரிந்துகொள்வது error handling-இன் நடைமுறை வரம்பை உள்ளடக்குகிறது, இது robust APIs-ஐ உருவாக்குவதற்கான முக்கியமான அறிவாக மாற்றுகிறது.