¿Qué cambió en Pydantic v2 y por qué es importante para FastAPI?

Question

Accepted Answer

**Pydantic v2** (una reescritura importante con su núcleo en **Rust**) trajo grandes ganancias de rendimiento y cambios en la API. Como Pydantic es central para FastAPI (validación, serialización, modelos), entender v2 es importante tanto para la velocidad como para escribir código moderno correcto.

## Por qué es importante

```text
Pydantic v2's validation core (pydantic-core) is written in RUST → typically
5–50x faster validation/serialization than v1.
→ Since FastAPI validates every request and serializes every response with Pydantic,
  this directly speeds up FastAPI apps.
```

Este es el cambio más impactante — validación más rápida significa FastAPI más rápido, sin cambios de código necesarios más allá de la actualización.

## Cambios clave en la API (v1 → v2)

```python
# method renames
model.dict()        → model.model_dump()          # to a dict
model.json()        → model.model_dump_json()      # to JSON
Model.parse_obj()   → Model.model_validate()        # from a dict

# validator decorators renamed
@validator("field")      → @field_validator("field")    # + must be a @classmethod
@root_validator         → @model_validator(mode="after")  # cross-field

# config: a class Config → model_config dict
class Config: ...        → model_config = ConfigDict(...)
```

Los métodos comunes y decoradores de validación fueron renombrados — importante al leer o escribir código, y al migrar bases de código v1.

## Comportamiento más estricto y claro

```text
✓ Stricter type coercion by default (fewer surprising silent conversions)
✓ Clearer, more detailed validation errors
✓ Better support for strict vs lax modes, computed fields, serialization control
✓ pydantic-settings split into its own package (BaseSettings moved there)
```

## Por qué esto es importante para FastAPI específicamente

```text
FastAPI uses Pydantic for: request body validation, response_model serialization,
query/path validation, settings, and the OpenAPI schema. So Pydantic v2's:
  ✓ speed → faster request handling across the board
  ✓ API changes → you must use the v2 syntax (model_dump, field_validator, etc.)
  ✓ behavior → stricter, more predictable validation
Modern FastAPI versions require/use Pydantic v2.
```

## Por qué importa

Entender Pydantic v2 es importante para desarrolladores de FastAPI porque Pydantic es la base de las características principales de FastAPI (validación, serialización, modelos, configuraciones, documentación), por lo que su cambio de versión importante afecta directamente tanto al rendimiento como a la forma en que escribes código.

El beneficio principal — un **núcleo basado en Rust que proporciona validación/serialización 5–50x más rápida** — acelera directamente las aplicaciones de FastAPI (que validan cada solicitud y serializan cada respuesta a través de Pydantic), una ganancia de rendimiento significativa lograda simplemente estar en v2.

Igualmente importante son los **cambios de API**: los métodos renombrados (`model_dump`/`model_validate`) y decoradores de validación (`field_validator`/`model_validator`) significan que debes usar la sintaxis moderna para escribir código correcto, y reconocer estos cambios es esencial al leer código actual, escribir código nuevo o migrar bases de código v1 más antiguas (una tarea común en el mundo real).

El comportamiento de validación más estricto y claro también hace que las aplicaciones sean más predecibles.

Como las versiones modernas de FastAPI están construidas sobre Pydantic v2, saber qué cambió — las ganancias de rendimiento, la nueva API y las diferencias de comportamiento — es conocimiento importante de nivel senior para trabajar efectivamente con FastAPI actual, evitar patrones v1 obsoletos y entender por qué FastAPI funciona como lo hace.

Refleja conciencia de la base de trabajo del framework en evolución y es cada vez más relevante a medida que el ecosistema se estandariza en v2.