ਤੁਸ ਗਲਤੀਆਂ ਨੂੰ ਕਿਵੇਂ ਸੰਭਾਲਦੇ ਹੋ ਅਤੇ 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=...)` ਇੱਕ ਗਲਤੀ ਵਾਪਸ ਕਰਨ ਦਾ idiomatic ਤਰੀਕਾ ਹੈ — FastAPI ਇੱਕ JSON ਪ੍ਰਤੀਕ੍ਰਿਆ `{"detail": "..."}` ਦਿੱਤੇ ਗਏ status ਨਾਲ ਤਿਆਰ ਕਰਦਾ ਹੈ। `detail` ਕੋਈ ਵੀ JSON-ਸੀਰੀਏਲਾਈਜ਼ੇਬਲ ਮੁੱਲ (string, dict, list) ਹੋ ਸਕਦਾ ਹੈ।

## Validation ਗਲਤੀਆਂ ਆਪਵਿੱਚੋਂ (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()})
```

## ਇਹ ਕਿਉਂ ਮਾਏਨੇ ਰੱਖਦਾ ਹੈ

ਸਹੀ ਗਲਤੀ ਪ੍ਰਬੰਧਨ ਭਰੋਸੇਮੰਦ, ਪেशੇਵਾਰ API ਬਣਾਉਣ ਲਈ ਜরুरी ਹੈ, ਅਤੇ FastAPI ਦੀ ਪਹੁੰਚ ਸਾਫ ਅਤੇ ਇਕਸਾਰ ਹੈ।

Idiomatic `HTTPException` ਸਹੀ ਗਲਤੀ ਪ੍ਰਤੀਕ੍ਰਿਆਵਾਂ ਨੂੰ ਸਹੀ status codes ਅਤੇ ਸੁਨੇਹਿਆਂ ਨਾਲ ਵਾਪਸ ਕਰਨਾ ਆਸਾਨ ਬਣਾਉਂਦਾ ਹੈ — ਕਿਸੇ ਵੀ endpoint ਦੇ ਲਈ ਬੁਨਿਆਦੀ ਜੋ ਅਸਫਲ ਹੋ ਸਕਦਾ ਹੈ (ਨਹੀਂ ਲੱਭਿਆ, ਵਰਜਿਤ, ਖਰਾਬ state)।

ਬਰਾਬਰ ਮੂਲਵਾਨ ਇਹ ਹੈ ਕਿ **validation ਗਲਤੀਆਂ ਆਪਵਿੱਚੋਂ ਸੰਭਾਲੀ ਜਾਂਦੀਆਂ ਹਨ** (Pydantic ਅਸਫਲਤਾਵਾਂ ਤੁਹਾਡੇ ਕੋਡ ਤੋਂ ਬਿਨਾਂ ਯੋਜਨਾਬੱਧ 422 ਪ੍ਰਤੀਕ੍ਰਿਆਵਾਂ ਤਿਆਰ ਕਰਦੀਆਂ ਹਨ), ਅਤੇ **ਕਸਟਮ ਅਪਵਾਦ ਹ੍ਰ੍ਤਾ** ਤੁਹਾਨੂੰ ਆਪਣੀਆਂ ਡੋਮੇਨ ਅਪਵਾਦਾਂ ਨੂੰ ਪ੍ਰਤੀਕ੍ਰਿਆਵਾਂ ਨਾਲ ਮੈਪ ਕਰਨ ਅਤੇ ਸਾਰੇ API ਵਿੱਚ ਇੱਕ ਸਾਂਝਾ ਗਲਤੀ ਫਾਰਮੈਟ ਨੂੰ ਲਾਗੂ ਕਰਨ ਦਿੰਦੇ ਹਨ — ਦੋਵੇਂ ਮੈਨਟੇਨੇਬਿਲਟੀ (ਕੇਂਦ੍ਰੀਕ ਗਲਤੀ ਲੋਜਿਕ) ਅਤੇ ਕਲਾਇੰਟ ਅਨੁਭਵ (ਮੈਨੂੰ ਗਲਤੀ ਆਕਾਰ) ਨੂੰ ਸੁਧਾਰਦੇ ਹਨ।

`HTTPException`, ਆਪਵਿੱਚੋਂ validation ਗਲਤੀਆਂ, ਅਤੇ ਕਸਟਮ ਹ੍ਰ੍ਤਾਵਾਂ ਨੂੰ ਸਮਝਨਾ ਗਲਤੀ ਪ੍ਰਬੰਧਨ ਦੇ ਵਿਹਾਰਕ ਸਪੈਕਟ੍ਰਮ ਨੂੰ ਕਵਰ ਕਰਦਾ ਹੈ, ਜਿਸ ਨੂੰ ਮਜਬੂਤ API ਬਣਾਉਣ ਲਈ ਮਹੱਤਵਪੂਰਨ ਗਿਆਨ ਬਣਾਉਂਦਾ ਹੈ।