FastAPI માં Pydantic મોડેલ્સ શું છે?

Question

Accepted Answer

**Pydantic મોડેલ્સ** એમ ક્લાસ કર્યા હોય છે (`BaseModel` નું સબક્લાસિંગ) જે ડેટાના **માળખું, પ્રકારો અને માન્યતા નિયમો** વ્યાખ્યાયિત કરે છે। FastAPI તેમને હર જગ્યાએ ઉપયોગ કરે છે — વિનંતીના શરીર, પ્રતિક્રિયા આકારો અને સેટિંગ્સ માટે — તેમને તેની પ્રકાર-આધારિત ડિઝાઇનનો હૃદય બનાવે છે.

## મોડલ વ્યાખ્યાયિત કરવું

```python
from pydantic import BaseModel, EmailStr, Field

class User(BaseModel):
    name: str
    email: EmailStr                          # validates email format
    age: int = Field(ge=0, le=120)            # constraint: 0 <= age <= 120
    is_active: bool = True                    # default value
    tags: list[str] = []                      # typed list with a default
```

પ્રતિ ક્ષેત્ર પ્રકાર અને વૈકલ્પિક અવરોધો/ડિફોલ્ટ ઘોષણા કરે છે। Pydantic આ વ્યાખ્યાની વિરુદ્ધ ડેટાને માન્ય કરે છે અને યોગ્ય જ્યાં પ્રકારો રૂપાંતરિત કરે છે.

## આપોઆપ માન્યતા અને પાર્સિંગ

```python
@app.post("/users")
def create_user(user: User):                  # FastAPI builds & validates a User from the body
    return user                               # already validated here
# valid JSON → a typed User object; invalid → automatic 422 with field-level errors
```

જ્યારે પરિમાણ પ્રકાર તરીકે ઉપયોગ કરવામાં આવે છે, FastAPI JSON વિનંતીના શરીરને મોડલમાં પાર્સ કરે છે, **હર ક્ષેત્રને માન્ય** કરે છે અને બરોબર શું ખોટું છે તે સૂચિબદ્ધ કરતી માળખાબદ્ધ 422 ભૂલ પરત કરે છે — બધું આપોઆપ.

## Pydantic તમને શું આપે છે

```text
✓ Validation — type checks + constraints (lengths, ranges, formats), clear errors
✓ Parsing/coercion — "5" → 5, ISO string → datetime, etc.
✓ Serialization — model.model_dump() / model_dump_json() → dict/JSON
✓ Editor support — full autocomplete & type checking on model attributes
✓ Self-documenting — the model defines the schema used in the auto-generated docs
```

## સત્યનો એક જ સ્ત્રોત

```text
One Pydantic model drives: request validation, the response schema, the OpenAPI docs,
and typed access in your code → define the data shape ONCE.
```

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

Pydantic મોડેલ્સ FastAPI ના ખૂણાપથર છે — તમે તમારું API સ્વીકારે છે અને પરત કરે છે તે ડેટાને વ્યાખ્યાયિત અને માન્ય કરવાનો આ વિધાન છે, અને લગભગ બધા FastAPI લક્ષણો તેમાંથી વહે છે.

તેમને સમજવું આવશ્યક છે કારણ કે તેઓ આપોઆપ **માન્યતા** (સુરક્ષા અને મજબૂતાઈ માટે જટિલ — ક્યારોય કાચો ઇનપુટ પર વિશ્વાસ કર્યો), પાર્સિંગ/જબરદસ્તી, સીરીયલાઇজેશન અને સંપાદક સમર્થન, બધું એક જ ઘોષણાત્મક વર્ગમાંથી પ્રદાન કરે છે.

તેઓ **સત્યનું એક જ સ્ત્રોત** તરીકે કામ કરે છે: એક મોડેલ વિનંતીની માન્યતા, પ્રતિક્રિયાનો આકાર અને આપોઆપ જનરેટ કરવામાં આવતો ડોક્યુમેન્ટેશન ચલાવે છે.

યह પ્રકાર-આધારિત, ડિફોલ્ટ માટે માન્ય અભિગમ — મજબૂત ઇનપુટ માન્યતા અને સ્પષ્ટ ભૂલ સંદેશા અનિવાર્યપણે મફતમાં મેળવવું — FastAPI એટલો ઉત્પાદક અને સુરક્ષિત છે તેનું મુખ્ય કારણ છે, Pydantic મોડેલ્સને મૌલિક, આવશ્યક-માસ્ટર જ્ઞાન બનાવે છે.