మీరు ఎ러ర్‌లను ఎలా నిర్వహిస్తారు మరియు HTTP exceptions ఎలా raise చేస్తారు?

Question

Accepted Answer

FastAPI exceptions raise చేయడం ద్వారా ఎర్ర్‌లను నిర్వహిస్తుంది, అవి సరైన HTTP responses‌లో మార్చబడతాయి. `HTTPException` చాలా cases‌లను కవర్ చేస్తుంది; custom exception handlers మీకు error formatting‌ను globally నియంత్రించడానికి అనుమతిస్తాయి.

## HTTPException Raise చేయడం

```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 way — FastAPI ఇచ్చిన status‌తో `{"detail": "..."}` JSON response ఉత్పత్తి చేస్తుంది. `detail` ఏదైనా JSON-serializable value (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 మీ own (domain) exceptions‌లను responses‌కు map చేయడానికి, error formatting‌ను centralizing చేయడానికి మరియు handler code‌ను clean ఉంచడానికి అనుమతిస్తాయి.

## 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 విశ్వసనీయమైన, professional APIs‌లను రూపొందించడానికి సవalsential, మరియు FastAPI యొక్క approach clean మరియు consistent.

Idiomatic `HTTPException` సరైన error responses‌లను appropriate status codes మరియు messages‌తో return చేయడానికి సులభం చేస్తుంది — ఏదైనా endpoint‌కు ఆధారమైనది, ఇది fail కానక్కర్లేనిది (not found, forbidden, bad state).

స్థితిలో సమానంగా విలువైనది **validation errors స్వయంచాలక**ంగా నిర్వహించబడతాయి (Pydantic failures structured 422 responses‌లను మీ నుండి కోడ్ లేకుండా ఉత్పత్తి చేస్తాయి), మరియు **custom exception handlers** మీ own domain exceptions‌లను responses‌కు map చేయడానికి మరియు మొత్తం API‌లో consistent error format‌ను enforce చేయడానికి అనుమతిస్తాయి — maintainability (centralized error logic) మరియు client experience (predictable error shapes) రెండినీ మెరుగుపరుస్తుంది.

`HTTPException`, automatic validation errors, మరియు custom handlers‌ను అర్థం చేసుకోవడం error handling‌కు practical spectrum‌ను covers చేస్తుంది, robust APIs‌లను రూపొందించడానికి ఇది ముఖ్యమైన knowledge చేస్తుంది.