Validación de datos con Pydantic 2

Crear modelo Pydantic

Los modelos Pydantic son clases especiales que nos permiten definir la estructura y tipos de datos que esperamos recibir en nuestras API. Cuando FastAPI recibe una petición, utiliza estos modelos para validar automáticamente que los datos cumplan con los requisitos especificados.

Un modelo Pydantic se crea heredando de la clase BaseModel que proporciona la librería. Esta clase base incluye toda la funcionalidad necesaria para la validación automática y conversión de tipos.

Definición básica de un modelo

Para crear nuestro primer modelo, necesitamos importar BaseModel desde Pydantic y definir una clase que herede de ella:

from pydantic import BaseModel

class Usuario(BaseModel):
    nombre: str
    edad: int
    activo: bool

En este ejemplo, hemos definido un modelo Usuario con tres campos: nombre de tipo string, edad de tipo entero y activo de tipo booleano. Pydantic utilizará estas anotaciones de tipo para validar automáticamente los datos entrantes.

Uso del modelo en FastAPI

Una vez definido el modelo, podemos utilizarlo en nuestras rutas de FastAPI. El framework se encarga automáticamente de la validación:

from fastapi import FastAPI
from pydantic import BaseModel

app = FastAPI()

class Usuario(BaseModel):
    nombre: str
    edad: int
    activo: bool

@app.post("/usuarios/")
def crear_usuario(usuario: Usuario):
    return {"mensaje": f"Usuario {usuario.nombre} creado correctamente"}

Cuando FastAPI recibe una petición POST en /usuarios/, automáticamente:

• Valida que los datos recibidos coincidan con el modelo Usuario
• Convierte los tipos de datos si es necesario
• Rechaza la petición si los datos no son válidos

Campos opcionales y valores por defecto

Podemos hacer que algunos campos sean opcionales o tengan valores por defecto utilizando la sintaxis estándar de Python:

from typing import Optional
from pydantic import BaseModel

class Producto(BaseModel):
    nombre: str
    precio: float
    descripcion: Optional[str] = None
    disponible: bool = True

En este modelo, descripcion es opcional y puede ser None, mientras que disponible tiene un valor por defecto de True. Si no se proporciona este campo en la petición, Pydantic asignará automáticamente el valor predeterminado.

Validación automática de tipos

Pydantic realiza conversiones inteligentes cuando es posible. Por ejemplo, si enviamos el string "25" para un campo de tipo int, Pydantic lo convertirá automáticamente al entero 25:

class Configuracion(BaseModel):
    puerto: int
    debug: bool
    nombre_app: str

# Estos datos JSON serían válidos:
# {
#   "puerto": "8000",     # Se convierte a int
#   "debug": "true",      # Se convierte a bool
#   "nombre_app": "MiAPI"
# }

Si la conversión no es posible, Pydantic generará un error de validación que FastAPI devolverá automáticamente como una respuesta HTTP 422 con detalles específicos sobre qué campo causó el problema.

Modelos anidados

Los modelos Pydantic pueden contener otros modelos como campos, permitiendo crear estructuras de datos complejas:

class Direccion(BaseModel):
    calle: str
    ciudad: str
    codigo_postal: str

class Cliente(BaseModel):
    nombre: str
    email: str
    direccion: Direccion

En este caso, el campo direccion del modelo Cliente debe ser un objeto que cumpla con la estructura del modelo Direccion. Pydantic validará tanto el modelo principal como los modelos anidados.

Acceso a los datos del modelo

Una vez que FastAPI ha validado los datos usando el modelo Pydantic, podemos acceder a los campos del modelo como atributos normales de Python:

@app.post("/clientes/")
def crear_cliente(cliente: Cliente):
    # Acceso directo a los campos
    nombre_cliente = cliente.nombre
    ciudad_cliente = cliente.direccion.ciudad
    
    return {
        "cliente": nombre_cliente,
        "ubicacion": ciudad_cliente,
        "datos_completos": cliente.model_dump()  # Convierte a diccionario
    }

El método model_dump() es especialmente útil cuando necesitamos convertir el modelo Pydantic de vuelta a un diccionario de Python para procesamiento adicional o almacenamiento.