Ce sunt modelele Pydantic în FastAPI?

Question

Accepted Answer

**Modelele Pydantic** sunt clase (subclase ale `BaseModel`) care definesc **structura, tipurile și regulile de validare** pentru date. FastAPI le folosește peste tot — pentru request bodies, response shapes și setări — făcând-le inima designului orientat pe tipuri.

## Definirea unui model

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

Fiecare câmp declară un tip și constrângeri/valori implicite opționale. Pydantic validează datele în raport cu această definiție și convertește tipurile acolo unde are sens.

## Validare și parsing automati

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

Când este utilizat ca tip de parametru, FastAPI analizează corpul requestului JSON în model, **validează** fiecare câmp și returnează o eroare 422 structurată care listează exact ceea ce este greșit — totul automat.

## Ce îți oferă 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
```

## O singură sursă de adevăr

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

## De ce este important

Modelele Pydantic sunt piatra de temelie a FastAPI — sunt modul în care definești și validezi datele pe care le acceptă și le returnează API-ul tău, iar aproape fiecare caracteristică FastAPI trece prin ele.

A le înțelege este esențial deoarece furnizează **validare** automată (critică pentru securitate și robustețe — niciodată nu ai încredere în intrarea brută), parsing/coerción, serializare și suport editor, toate dintr-o singură clasă declarativă.

Servesc drept **o singură sursă de adevăr**: un model conduce validarea requestului, forma răspunsului și documentația generată automat.

Această abordare orientată pe tipuri, validată implicit — obținerea unei validări robuste a intrării și a mesajelor de eroare clare în esență gratuit — este o parte importantă a motivului pentru care FastAPI este atât de productiv și sigur, făcând modelele Pydantic cunoștințe fundamentale, obligatorii.