O que mudou no Pydantic v2 e por que isso importa para FastAPI?

Question

Accepted Answer

**Pydantic v2** (uma reescrita completa com núcleo em **Rust**) trouxe grandes ganhos de desempenho e mudanças na API. Como Pydantic é central para FastAPI (validação, serialização, modelos), entender v2 importa tanto para velocidade quanto para escrever código correto e moderno.

## O destaque: muito mais rápido (núcleo em Rust)

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

Esta é a mudança mais impactante — validação mais rápida significa FastAPI mais rápido, sem necessidade de mudanças de código além da atualização.

## Principais mudanças de 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(...)
```

Os métodos comuns e decoradores de validador foram renomeados — importante ao ler ou escrever código, e ao migrar bases de código v1.

## Comportamento mais rigoroso e 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 que isso importa especificamente para FastAPI

```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 que isso importa

Entender Pydantic v2 é importante para desenvolvedores de FastAPI porque Pydantic é a base dos recursos principais de FastAPI (validação, serialização, modelos, configurações, documentação), então sua mudança de versão maior afeta diretamente tanto desempenho quanto a forma como você escreve código.

O benefício principal — um **núcleo baseado em Rust entregando validação/serialização 5–50x mais rápida** — acelera diretamente aplicações FastAPI (que validam cada requisição e serializam cada resposta através do Pydantic), um ganho de desempenho significativo alcançado apenas por estar em v2.

Igualmente importante são as **mudanças de API**: os métodos renomeados (`model_dump`/`model_validate`) e decoradores de validador (`field_validator`/`model_validator`) significam que você deve usar a sintaxe moderna para escrever código correto, e reconhecer essas mudanças é essencial ao ler código atual, escrever novo código ou migrar bases de código v1 mais antigas (uma tarefa comum no mundo real).

O comportamento de validação mais rigoroso e claro também torna as aplicações mais previsíveis.

Como versões modernas de FastAPI são construídas sobre Pydantic v2, saber o que mudou — os ganhos de desempenho, a nova API e as diferenças comportamentais — é conhecimento importante em nível sênior para trabalhar efetivamente com FastAPI atual, evitar padrões v1 desatualizados e entender por que FastAPI executa como executa.

Reflete consciência da base em evolução do framework e é cada vez mais relevante conforme o ecossistema se padroniza em v2.