Skip to content

3. El modelo de la acción

Una acción necesita información enviada por el navegador: los parámetros de la URL ([?name=martin&age=42]), los campos de un formulario, el cuerpo JSON de la solicitud y, a veces, un encabezado de la solicitud HTTP. El curso original llama a toda esta información el modelo de la acción. Este capítulo muestra cómo una acción obtiene esta información, la convierte al tipo correcto y la valida. Este proceso se llama enlace de datos (data binding).

[Flask] es aquí mucho más minimalista que otros frameworks: da acceso a la información de la solicitud en forma de cadenas de caracteres y no hace más. Convertir ["42"] en el entero 42, verificar que un nombre tenga al menos dos caracteres y ensamblar los campos en un objeto: todo esto es responsabilidad de la aplicación. Lo haremos primero a mano (ejemplo 07) y luego con la biblioteca [Pydantic] (ejemplos 08 a 12), que describe un modelo mediante una clase en la que cada campo especifica su tipo y sus restricciones. En el próximo capítulo, los formularios HTML se manejarán con otra biblioteca, [WTForms], diseñada específicamente para ellos; [Pydantic] sigue siendo la herramienta natural para los parámetros de una URL y para los cuerpos JSON de la API.

Nota sobre la terminología: en el capítulo siguiente, la palabra “modelo” designará principalmente los datos que una acción transmite a su vista. El modelo de una acción, tal como se usa en este capítulo, es lo que ella recibe.

Los ejemplos 07 a 12 se ejecutan igual que los del capítulo anterior: abra un terminal en el directorio del ejemplo, con el entorno virtual activado ([python app.py]); [Ctrl-C] detiene el servidor. Sus archivos [app.py] son todos similares: una fábrica [create_app] que crea la aplicación, configura el proveedor JSON (acentos conservados, claves en su orden original; vea el ejemplo 03) y registra un blueprint. Solo los comentaremos cuando introduzcan algo nuevo.

3.1. Ejemplo 07: los parámetros de la URL

Los parámetros de la URL son la porción que sigue a [?]: [?name=martin&age=42]. Esta porción se llama cadena de consulta (*query string*). Cada parámetro es un par [name=value]; los pares se separan con [&]. El archivo [controllers/parameters.py]:

# controllers/parameters.py: los parámetros de la URL (la "query string")
from flask import Blueprint, abort, request

parameters = Blueprint("parameters", __name__, url_prefix="/parameters")


# /parameters/action01?name=martin: request.args contiene los parámetros de
# la URL; get devuelve el valor del parámetro, o None si falta
@parameters.get("/action01")
def action01():
    name = request.args.get("name")
    return f"name = [{name}], of type {type(name).__name__}"


# /parameters/action02?age=42: type=int CONVIERTE el valor (una cadena) en
# un entero; un parámetro ausente, o que no es un entero, da None
@parameters.get("/action02")
def action02():
    age = request.args.get("age", type=int)
    return f"age = [{age}], of type {type(age).__name__}"


# /parameters/action03?age=42: un parámetro OBLIGATORIO; su ausencia, o un
# valor que no es un entero, detiene la acción con una respuesta 400 (Bad Request)
@parameters.get("/action03")
def action03():
    text = request.args.get("age")
    if text is None:
        # abort lanza una excepción, que Flask convierte en una respuesta de error
        abort(400, "the [age] parameter is required")
    # la conversión corre por nuestra cuenta
    try:
        age = int(text)
    except ValueError:
        abort(400, f"[{text}] is not an integer")
    return f"age = [{age}], of type {type(age).__name__}"


# /parameters/action04?page=2: un valor predeterminado si falta el parámetro
@parameters.get("/action04")
def action04():
    page = request.args.get("page", default=1, type=int)
    return f"page = [{page}]"


# /parameters/action05?q=flask: el nombre del parámetro de la URL no es necesariamente
# el de la variable de Python
@parameters.get("/action05")
def action05():
    search = request.args.get("q")
    return f"search = [{search}]"


# /parameters/action06?name=martin&age=42: todos los parámetros a la vez, como un diccionario
@parameters.get("/action06")
def action06():
    return request.args.to_dict()
  • línea 11: [request.args] contiene los parámetros de la URL, ya decodificados por [Werkzeug]. Es un diccionario especial, un [MultiDict], que, como veremos en el ejemplo 10, acepta varios valores por clave. Su método [get] devuelve el valor de un parámetro, o [None] si está ausente. A diferencia de [request.args["name"]], que lanzaría una excepción ante un parámetro ausente, [get] nunca provoca un error;
  • línea 12: la acción muestra el valor y su tipo: [type(x)] es la clase de [x], y [__name__] es el nombre de esa clase. Un valor obtenido de la URL es siempre una cadena ([str]);
  • línea 19: el parámetro [type] de [get] especifica una función de conversión que se aplica a la cadena: en este caso, [int], la clase de los enteros, cuya llamada [int("42")] devuelve 42. Si la conversión falla ([int("abc")] lanza un [ValueError]), [get] devuelve [None], igual que ante un parámetro ausente: la acción no puede distinguir los dos casos y el error de entrada pasa inadvertido;
  • Líneas 26–35: un parámetro obligatorio y una conversión manual que distingue entre los dos errores posibles. [abort(400, message)] termina la acción con una respuesta 400 (*Bad Request*: la solicitud no es válida), acompañada del mensaje (véase el ejemplo 03). La instrucción [try] / [except ValueError] captura la excepción lanzada por [int];
  • línea 42: un valor predeterminado, que se usa si falta el parámetro (o si su conversión falla). Es un caso típico para el número de página de una lista;
  • línea 50: no es obligatorio que la variable [Python] tenga el mismo nombre que el parámetro de la URL. Los motores de búsqueda suelen usar un parámetro corto, [q] (*query*);
  • línea 57: [to_dict()] convierte [MultiDict] en un diccionario [Python] estándar (conservando solo el primer valor de cada parámetro), que la acción devuelve como respuesta: [Flask] lo transforma en JSON (véase el ejemplo 03).

Probemos cada acción con [curl]. Un parámetro presente y luego ausente:

curl -i "http://localhost:5000/parameters/action01?name=martin"
curl http://localhost:5000/parameters/action01
1
2
3
4
5
6
HTTP/1.1 200 OK
Content-Type: text/html; charset=utf-8
Content-Length: 28

name = [martin], of type str
name = [None], of type NoneType

Las comillas alrededor de la URL son necesarias en una terminal: sin ellas, el shell interpretaría [&] (que ejecuta un comando en segundo plano en [Linux]) y [?]. Un valor que contenga espacios o caracteres especiales debe estar codificado en la URL: un espacio se convierte en [%20], y [&] se convierte en [%26] (de lo contrario, separaría dos parámetros). El navegador lo hace automáticamente; con [curl], hay que escribirlo explícitamente. [Werkzeug] decodifica el valor antes de almacenarlo en [request.args]:

curl "http://localhost:5000/parameters/action01?name=jean%20dupont%20%26%20sons"
name = [jean dupont & sons], of type str

La conversión mediante [type=int], que primero tuvo éxito y luego falló:

curl "http://localhost:5000/parameters/action02?age=42"
curl "http://localhost:5000/parameters/action02?age=abc"
age = [42], of type int
age = [None], of type NoneType

El parámetro obligatorio de la acción 03, ausente y luego no válido:

curl -i http://localhost:5000/parameters/action03
curl "http://localhost:5000/parameters/action03?age=abc"
HTTP/1.1 400 BAD REQUEST
Content-Type: text/html; charset=utf-8
Content-Length: 122

<!doctype html>
<html lang=en>
<title>400 Bad Request</title>
<h1>Bad Request</h1>
<p>the [age] parameter is required</p>
<!doctype html>
<html lang=en>
<title>400 Bad Request</title>
<h1>Bad Request</h1>
<p>[abc] is not an integer</p>

El valor predeterminado y el parámetro renombrado:

1
2
3
curl http://localhost:5000/parameters/action04
curl "http://localhost:5000/parameters/action04?page=3"
curl "http://localhost:5000/parameters/action05?q=flask"
1
2
3
page = [1]
page = [3]
search = [flask]

Por último, todos los parámetros a la vez. El parámetro [name] aparece dos veces: [to_dict()] conserva solo el primer valor.

curl "http://localhost:5000/parameters/action06?name=martin&age=42&name=durand"
1
2
3
4
{
  "name": "martin",
  "age": "42"
}

La edad siguió siendo una cadena (["42"], entre comillas en JSON): no se solicitó ninguna conversión. En un navegador (aquí [Chromium]), el JSON aparece en una sola línea: [Flask] solo indenta el JSON en modo de depuración, y la captura de pantalla se tomó sin él; la casilla “Pretty-print” lo mostraría indentado. Por cierto, la barra de direcciones muestra la codificación de los caracteres acentuados en la URL ([é] se convierte en [%C3%A9], con sus dos bytes en [UTF-8]):

Image

Este primer ejemplo ilustra los límites del enfoque manual: para cada parámetro, hay que escribir la lectura, la conversión y el tratamiento de los valores ausentes y de los errores. Con diez parámetros, el código de la acción quedaría abrumado por estas verificaciones. Es preferible describir lo que se espera y dejar que una biblioteca se encargue de la verificación. Ese es el objetivo del siguiente ejemplo.

3.2. Ejemplo 08: un modelo de acción descrito por una clase

[Pydantic] es la biblioteca de validación de datos más utilizada en [Python] (es el núcleo del framework [FastAPI]). Describe los datos esperados mediante una clase: cada atributo tiene un tipo y, opcionalmente, restricciones. [Pydantic] se encarga de convertir los datos recibidos a esos tipos y de validar las restricciones. Se instala en el entorno virtual del ejemplo (archivo [requirements.txt]).

3.2.1. El modelo: models/person.py

# models/person.py: el modelo de la acción, una clase Pydantic en la que cada
# campo lleva su tipo y sus restricciones
from typing import Annotated, Literal

from pydantic import BaseModel, ConfigDict, EmailStr, Field


class PersonModel(BaseModel):
    # a las cadenas recibidas se les quitan los espacios que las rodean
    model_config = ConfigDict(str_strip_whitespace=True)

    # obligatorio (sin valor predeterminado), de 2 a 20 caracteres
    name: Annotated[str, Field(min_length=2, max_length=20)]
    # un entero ("42" se convierte en 42), entre 0 y 150
    age: Annotated[int, Field(ge=0, le=150)]
    # solo uno de estos tres valores
    title: Literal["Mr", "Mme", "Melle"]
    # opcional (None por defecto); si está presente, una dirección de correo válida
    email: EmailStr | None = None
  • Línea 8: Un modelo [Pydantic] es una clase que hereda de [BaseModel]. Sus atributos se declaran a nivel de clase, junto con sus tipos, como en una [dataclass] (ejemplo 06);
  • Línea 10: la configuración del modelo. [str_strip_whitespace=True] elimina los espacios que rodean las cadenas recibidas: un nombre ingresado como [" martin "] se convierte en ["martin"] antes de ser validado. El atributo [model_config] no es un campo del modelo: [Pydantic] reconoce este nombre reservado;
  • Línea 13: el campo [name]. [Annotated[str, Field(...)]] se lee “el tipo [str], anotado con [Field(...)]”. [Annotated], del módulo estándar [typing], permite adjuntar información adicional a un tipo, información que [Python] ignora pero que las bibliotecas leen: aquí, las restricciones de [Pydantic], una longitud de 2 a 20 caracteres ([min_length], [max_length]). El campo no tiene valor predeterminado: es obligatorio;
  • línea 15: el tipo [int]: [Pydantic] convierte la cadena ["42"] en el entero 42, y rechaza ["abc"]. Las restricciones [ge] (*greater or equal*) y [le] (*less or equal*) limitan el valor. También existen [gt] y [lt] para las desigualdades estrictas;
  • línea 17: [Literal["Mr", "Mme", "Melle"]] es el tipo de los tres valores enumerados, y solo de ellos;
  • línea 19: [EmailStr] es el tipo de una dirección de correo electrónico; [Pydantic] valida su sintaxis mediante la biblioteca [email-validator] (que también instala [requirements.txt]). [EmailStr | None]: una dirección, o [None]. El valor predeterminado [= None] hace que el campo sea opcional.

Este modelo describe los datos esperados; no contiene instrucciones de validación. Esto se conoce como un estilo declarativo.

3.2.2. La acción: controllers/persons.py

# controllers/persons.py: una acción cuyo modelo es una clase Pydantic
from flask import Blueprint, request

from models.person import PersonModel

persons = Blueprint("persons", __name__, url_prefix="/persons")


# /persons/action01?name=martin&age=42&title=Mr
# model_validate: Pydantic crea el objeto a partir del diccionario de parámetros
# (BINDING: conversión de las cadenas al tipo de cada campo), luego verifica
# las restricciones (VALIDACIÓN). Un modelo inválido lanza una ValidationError,
# convertida en una respuesta 400 por app.py: la acción se detiene allí
@persons.get("/action01")
def action01():
    person = PersonModel.model_validate(request.args.to_dict())
    return {
        # model_dump: el objeto como diccionario (serializable a JSON)
        "person": person.model_dump(),
        "ageType": type(person.age).__name__,
    }
  • Línea 16: el método de clase [model_validate] crea un objeto [PersonModel] a partir de un diccionario, en este caso el que contiene los parámetros de la URL. Realiza dos operaciones, en este orden: - el enlace (binding): cada valor del diccionario se asigna al campo del mismo nombre, tras convertirlo al tipo del campo (["42"] → 42); - la validación: se verifican las restricciones de cada campo (longitud, límites, valores permitidos, etc.).
  • Si alguno de los dos pasos falla, [model_validate] lanza una excepción [ValidationError], que contiene una lista de todos los errores (no solo el primero). La acción no la maneja: se detiene; veremos quién se encarga de ella;
  • línea 19: [model_dump()] devuelve el objeto como un diccionario, que [Flask] puede convertir a JSON;
  • línea 20: el tipo de la edad, para mostrar que la conversión se realizó.

3.2.3. Manejo de errores: app.py

# app.py: la aplicación del ejemplo 08
from flask import Flask
from pydantic import ValidationError

from controllers.persons import persons


def create_app():
    app = Flask(__name__)
    # JSON: acentos conservados, claves en su orden original (vea el ejemplo 03)
    app.json.ensure_ascii = False
    app.json.sort_keys = False
    app.register_blueprint(persons)

    # un modelo inválido: la excepción ValidationError de Pydantic se convierte,
    # para TODA la aplicación, en una respuesta 400 que detalla los errores
    @app.errorhandler(ValidationError)
    def invalid_model(e: ValidationError):
        errors = [{"field": ".".join(str(x) for x in err["loc"]), "message": err["msg"]}
                  for err in e.errors()]
        return {"status": 400, "errors": errors}, 400

    return app


if __name__ == "__main__":
    create_app().run(port=5000, debug=True)
  • Líneas 17–21: el decorador [@app.errorhandler(ValidationError)] registra un manejador de excepciones: cuando una acción lanza una [ValidationError] (o una excepción de una clase derivada), [Flask] llama a esta función, pasándole la excepción como parámetro, y devuelve su valor de retorno como respuesta. Al estar declarado a nivel de la aplicación, el manejador se aplica a todas sus acciones: toda acción que valide un modelo se beneficia de él, sin tener que escribir una sola línea de código de manejo de errores;
  • Línea 19: [e.errors()] devuelve la lista de errores. Cada error es un diccionario; conservamos dos datos: [loc] (*location*), el campo afectado, en forma de tupla ([("name",)]; véase el ejemplo 10 para una tupla más larga), y [msg], el mensaje. La expresión [[... for err in e.errors()]] es una comprensión de listas: construye una lista aplicando la expresión de la izquierda a cada elemento;
  • línea 21: una tupla [(body, code)] (véase el ejemplo 03): un diccionario, convertido a JSON, y el código 400.

3.2.4. Ejecución

Una entrada válida:

curl -i "http://localhost:5000/persons/action01?name=martin&age=42&title=Mr"
HTTP/1.1 200 OK
Content-Type: application/json
Content-Length: 116

{
  "person": {
    "name": "martin",
    "age": 42,
    "title": "Mr",
    "email": null
  },
  "ageType": "int"
}

La edad efectivamente se convirtió en un entero (sin comillas en JSON), y la dirección ausente es [None] ([null] en JSON). Un nombre rodeado de espacios ([%20]) y una dirección presente:

curl "http://localhost:5000/persons/action01?name=%20%20martin%20&age=42&title=Mme&email=martin@example.com"
1
2
3
4
5
6
7
8
9
{
  "person": {
    "name": "martin",
    "age": 42,
    "title": "Mme",
    "email": "martin@example.com"
  },
  "ageType": "int"
}

Sin parámetros: faltan los tres campos obligatorios.

curl -i http://localhost:5000/persons/action01
HTTP/1.1 400 BAD REQUEST
Content-Type: application/json
Content-Length: 248

{
  "status": 400,
  "errors": [
    {
      "field": "name",
      "message": "Field required"
    },
    {
      "field": "age",
      "message": "Field required"
    },
    {
      "field": "title",
      "message": "Field required"
    }
  ]
}

Cuatro campos no válidos a la vez:

curl "http://localhost:5000/persons/action01?name=m&age=abc&title=Mlle&email=xx"
{
  "status": 400,
  "errors": [
    {
      "field": "name",
      "message": "String should have at least 2 characters"
    },
    {
      "field": "age",
      "message": "Input should be a valid integer, unable to parse string as an integer"
    },
    {
      "field": "title",
      "message": "Input should be 'Mr', 'Mme' or 'Melle'"
    },
    {
      "field": "email",
      "message": "value is not a valid email address: An email address must have an @-sign."
    }
  ]
}

Todos los errores se informan a la vez, lo que permite al usuario corregirlo todo de una sola vez. Los mensajes están en inglés: [Pydantic] no está traducido. El siguiente ejemplo los reemplaza por mensajes propios.

3.3. Ejemplo 09: Validación realizada por la acción

En el ejemplo 08, un formulario no válido interrumpe la acción, y responde el manejador de la aplicación. Esto resulta cómodo para una API, cuyos clientes son programas que esperan una respuesta de error estandarizada. Sin embargo, una página web suele preferir volver a mostrar el formulario con los mensajes de error: en ese caso, la acción debe decidir cómo tratar un modelo no válido. El modelo [models/person.py] es el del ejemplo 08.

3.3.1. Mensajes personalizados: models/messages.py

# models/messages.py: los mensajes de los errores de validación, en inglés.
# Cada error de Pydantic es un diccionario: su TIPO ("missing",
# "string_too_short"...), el campo afectado (loc), un mensaje en inglés (msg),
# y el contexto (ctx): los valores de las restricciones ({"min_length": 2}...)
MESSAGES = {
    "missing": "the field is required",
    "string_too_short": "{min_length} character(s) at least",
    "string_too_long": "{max_length} character(s) at most",
    "int_parsing": "an integer is expected",
    "greater_than_equal": "the value must be greater than or equal to {ge}",
    "less_than_equal": "the value must be less than or equal to {le}",
    "literal_error": "unknown value",
    "value_error": "invalid value",
    "too_short": "{min_length} item(s) at least",
}


# el nombre del campo: loc es una tupla, ("name",) o ("color", 1) para el 2.º
# elemento de una lista
def field(error: dict) -> str:
    return ".".join(str(x) for x in error["loc"])


# nuestro propio mensaje; un tipo de error desconocido conserva el mensaje de Pydantic
def message_en(error: dict) -> str:
    template = MESSAGES.get(error["type"])
    if template is None:
        return error["msg"]
    # format reemplaza {min_length}... por los valores del contexto
    return template.format(**error.get("ctx", {}))
  • Líneas 5–14: cada error de [Pydantic] tiene un tipo y un identificador único (["missing"] para un campo ausente, ["string_too_short"] para una cadena demasiado corta, etc.), independiente del mensaje en inglés. El diccionario [MESSAGES] asocia un mensaje propio a cada tipo. Algunos contienen etiquetas como [{min_length}], [{ge}]...: la documentación de [Pydantic] proporciona, para cada tipo de error, los valores de su contexto;
  • líneas 20–21: el nombre del campo que causa el error, tomado de la tupla [loc]. [".".join(...)] ensambla los elementos de la tupla, convertidos en cadenas, separándolos con puntos;
  • líneas 25–30: nuestro propio mensaje de error. [MESSAGES.get(...)] devuelve [None] para un tipo de error que no se encuentra en el diccionario; en ese caso, se usa el mensaje en inglés de [Pydantic]. En caso contrario, [format] reemplaza cada aparición de [{name}] en el mensaje por el valor del mismo nombre del contexto: ["{min_length} character(s) at least".format(min_length=2)] produce ["2 character(s) at least"]. La notación [**dictionary] pasa las entradas del diccionario como parámetros con nombre; [error.get("ctx", {})] devuelve un diccionario vacío para un error sin contexto.

Esta técnica (traducir según el tipo de error) es la que se usa en el caso de estudio: allí los mensajes se identifican mediante claves, que se traducen al idioma del usuario.

3.3.2. La acción: controllers/persons.py

# controllers/persons.py: es la acción la que decide qué hacer con un modelo inválido
from flask import Blueprint, request
from markupsafe import escape
from pydantic import ValidationError

from models.messages import field, message_en
from models.person import PersonModel

persons = Blueprint("persons", __name__, url_prefix="/persons")


@persons.get("/action01")
def action01():
    try:
        person = PersonModel.model_validate(request.args.to_dict())
    except ValidationError as e:
        # los errores, campo por campo: e.errors() entrega su lista
        items = "".join(f"<li>{field(error)}: {message_en(error)}</li>" for error in e.errors())
        return f"<p>The form contains errors:</p><ul>{items}</ul>"
    # escape: el nombre ingresado se inserta en HTML; sus caracteres < > & " '
    # se reemplazan por &lt; &gt;... (de lo contrario, una entrada podría inyectar HTML)
    return f"<p>Welcome {person.title} {escape(person.name)} ({person.age} years old)</p>"
  • Líneas 14–19: la propia acción intercepta la [ValidationError] dentro de un bloque [try] / [except]. Si se produce un error, construye una lista HTML de errores ([<ul>], una etiqueta [<li>] por error);
  • línea 22: si tiene éxito, un mensaje de bienvenida. El nombre se pasa por la función [escape] de la biblioteca [markupsafe] (instalada con [Flask]). [escape] reemplaza los caracteres que tienen significado en HTML ([<], [>], [&], ["], [']) por sus entidades ([&lt;], [&gt;]...): se mostrarán tal cual en lugar de ser interpretados. Sin esta precaución, un usuario podría ingresar un “nombre” que contenga HTML, o incluso [JavaScript], que se ejecutaría en el navegador de cualquiera que viera la página. Esta es la vulnerabilidad de seguridad más común en la web: la inyección de scripts (*XSS*, *cross-site scripting*). El título y la edad no requieren esta protección: sus valores han sido validados por el modelo (uno de tres valores permitidos, un entero). En el próximo capítulo, el motor de vistas [Jinja2] realizará este escape automáticamente para cualquier valor insertado en una página.

Una entrada válida, seguida de una entrada con cuatro errores:

Image

Image

La respuesta sin procesar a la segunda solicitud, y la respuesta para un nombre que contiene HTML:

curl "http://localhost:5000/persons/action01?name=m&age=abc&title=Mx&email=xx"
curl "http://localhost:5000/persons/action01?name=%3Cb%3Emartin%3C/b%3E&age=42&title=Mr"
<p>The form contains errors:</p><ul><li>name: 2 character(s) at least</li><li>age: an integer is expected</li><li>title: unknown value</li><li>email: invalid value</li></ul>
<p>Welcome Mr &lt;b&gt;martin&lt;/b&gt; (42 years old)</p>

El nombre [<b>martin</b>] (codificado como [%3Cb%3E...] en la URL) se muestra tal cual, sin negrita: sus etiquetas han sido neutralizadas. Observe que esta vez la respuesta tiene un código de estado 200: esto se debe a que la acción optó por devolver una página normal que contiene los errores.

3.4. Ejemplo 10: Parámetros múltiples

El mismo parámetro puede aparecer varias veces en una URL: [?color=red&color=green]. Esto es lo que envía un navegador para un grupo de casillas de verificación con el mismo nombre, o para una lista de selección múltiple (véase el próximo capítulo). El archivo [controllers/arrays.py]:

# controllers/arrays.py: un parámetro que aparece varias veces en la URL
from flask import Blueprint, request
from pydantic import ValidationError

from models.choice import ChoiceModel
from models.messages import field, message_en

arrays = Blueprint("arrays", __name__, url_prefix="/arrays")


# /arrays/action01?color=red&color=green: get devuelve solo el PRIMER valor
@arrays.get("/action01")
def action01():
    return {"color": request.args.get("color")}


# /arrays/action02?color=red&color=green: getlist devuelve TODOS los
# valores, en una lista (vacía si falta el parámetro)
@arrays.get("/action02")
def action02():
    colors = request.args.getlist("color")
    return {"color": colors, "count": len(colors)}


# /arrays/action03?color=red: una lista, validada por ChoiceModel
@arrays.get("/action03")
def action03():
    colors = request.args.getlist("color")
    try:
        ChoiceModel(color=colors)
        errors = []
    except ValidationError as e:
        errors = [f"{field(error)}: {message_en(error)}" for error in e.errors()]
    return {"colors": colors, "valid": not errors, "errors": errors}
  • línea 14: [get] devuelve únicamente el primer valor del parámetro;
  • línea 21: [getlist] devuelve todos sus valores en una lista, que está vacía si falta el parámetro. Esta es la característica distintiva de [MultiDict]: conserva la lista de valores de cada clave;
  • líneas 27–34: la lista se valida mediante un modelo [Pydantic]. Esta vez, el modelo se construye con una llamada estándar, [ChoiceModel(color=colors)], con los campos pasados como parámetros con nombre: esto equivale a [model_validate] sobre un diccionario. El objeto creado no sirve para nada más que para validar: no se conserva. La expresión [not errors] equivale a [True] para una lista vacía.

El modelo [models/choice.py]:

# models/choice.py: una lista, y una restricción sobre CADA elemento de la lista
from typing import Annotated, Literal

from pydantic import BaseModel, Field


class ChoiceModel(BaseModel):
    # list[Literal[...]]: cada elemento debe ser "red", "green" o "blue";
    # min_length=1: la lista debe contener al menos un elemento
    color: Annotated[list[Literal["red", "green", "blue"]], Field(min_length=1)]
  • Línea 10: el tipo [list[Literal["red", "green", "blue"]]] es el de una lista en la que cada elemento es uno de tres colores. La restricción [min_length=1], aplicada a una lista, se refiere al número de elementos: debe haber al menos uno.

El archivo [models/messages.py] es el del ejemplo 09. Los resultados:

1
2
3
curl "http://localhost:5000/arrays/action01?color=red&color=green"
curl "http://localhost:5000/arrays/action02?color=red&color=green"
curl http://localhost:5000/arrays/action02
{
  "color": "red"
}
{
  "color": [
    "red",
    "green"
  ],
  "count": 2
}
{
  "color": [],
  "count": 0
}

La validación primero tuvo éxito, luego falló por un color desconocido y después por una lista vacía:

1
2
3
curl "http://localhost:5000/arrays/action03?color=red&color=blue"
curl "http://localhost:5000/arrays/action03?color=red&color=yellow"
curl http://localhost:5000/arrays/action03
{
  "colors": [
    "red",
    "blue"
  ],
  "valid": true,
  "errors": []
}
{
  "colors": [
    "red",
    "yellow"
  ],
  "valid": false,
  "errors": [
    "color.1: unknown value"
  ]
}
{
  "colors": [],
  "valid": false,
  "errors": [
    "color: 1 item(s) at least"
  ]
}

El error de “valor desconocido” se refiere a [color.1]: la tupla de error [loc] es [("color", 1)]; el campo y el índice del elemento problemático en la lista (el segundo, con los índices comenzando en 0).

3.5. Ejemplo 11: Los parámetros de una solicitud POST

Los ejemplos anteriores usaban solicitudes GET, cuyos parámetros están contenidos en la URL. Una solicitud POST transporta sus datos en su cuerpo, en dos formas principales:

  • campos de un formulario HTML: el cuerpo tiene la misma sintaxis que una cadena de consulta ([name=martin&age=42]), y su tipo (encabezado [Content-Type]) es [application/x-www-form-urlencoded];
  • un documento JSON, enviado por un programa ([JavaScript] en una página, cliente de una API...): el tipo es [application/json].

El archivo [controllers/post.py]:

# controllers/post.py: los parámetros de una solicitud POST
from flask import Blueprint, request
from pydantic import ValidationError

from models.messages import field, message_en
from models.person import PersonModel

post = Blueprint("post", __name__, url_prefix="/post")


# los campos de un formulario HTML (cuerpo application/x-www-form-urlencoded):
# request.form, un diccionario "multi" (MultiDict), como request.args
@post.post("/action01")
def action01():
    return {
        "receivedType": request.content_type,
        # flat=False: cada campo -> la lista de sus valores
        "fields": request.form.to_dict(flat=False),
    }


# un cuerpo JSON: get_json lo deserializa (diccionario, lista...); un cuerpo
# que no es JSON -> error 415 (tipo no admitido) o 400 (JSON mal formado)
@post.post("/action02")
def action02():
    return {"receivedType": request.content_type, "body": request.get_json()}


# un solo campo del formulario
@post.post("/action03")
def action03():
    name = request.form.get("name")
    return f"name = [{name}]"


# los campos del formulario, enlazados y validados por la clase PersonModel
@post.post("/action04")
def action04():
    try:
        person = PersonModel.model_validate(request.form.to_dict()).model_dump()
        errors = []
    except ValidationError as e:
        person = None
        errors = sorted(f"{field(error)}: {message_en(error)}" for error in e.errors())
    return {"person": person, "valid": not errors, "errors": errors}
  • línea 13: [post.post(...)]: el primer [post] es el blueprint, el segundo es el método que declara una ruta para el método HTTP POST (véase el ejemplo 02);
  • línea 16: [request.content_type] es el encabezado [Content-Type] de la solicitud;
  • línea 18: [request.form] contiene los campos de un formulario enviado por POST. Al igual que [request.args], es un [MultiDict]. [to_dict(flat=False)] crea en realidad un diccionario donde cada valor es la lista de valores del campo;
  • línea 26: [request.get_json()] deserializa un cuerpo JSON: el texto JSON se convierte en un objeto [Python] (un diccionario para un objeto JSON, una lista para un arreglo JSON...). Si el cuerpo no está declarado como JSON, [get_json] provoca un error 415 (*Unsupported Media Type*); si lo está, pero el texto está mal formado, se produce un error 400;
  • línea 32: un campo, interpretado como parámetro de la URL;
  • líneas 38–45: el modelo [PersonModel] del ejemplo 08, esta vez vinculado a los campos del formulario. El código es el mismo que con los parámetros de la URL: solo cambia el origen del diccionario. [sorted] ordena los mensajes para garantizar una respuesta coherente.

Con [curl], la opción [-d] (*data*) envía un cuerpo; la solicitud pasa entonces a ser una solicitud POST, de tipo [application/x-www-form-urlencoded], a menos que la opción [-H] (*header*) especifique un tipo diferente. La opción [-X POST] establece explícitamente el método (aquí es opcional). Los campos de un formulario, incluido un campo repetido:

curl -i -X POST -d "name=martin&age=42&hobby=tennis&hobby=piano" http://localhost:5000/post/action01
HTTP/1.1 200 OK
Content-Type: application/json
Content-Length: 195

{
  "receivedType": "application/x-www-form-urlencoded",
  "fields": {
    "name": [
      "martin"
    ],
    "age": [
      "42"
    ],
    "hobby": [
      "tennis",
      "piano"
    ]
  }
}

Un cuerpo JSON, que contiene un entero y un arreglo:

curl -H "Content-Type: application/json" -d "{\"name\": \"martin\", \"age\": 42, \"children\": [\"léa\", \"tom\"]}" http://localhost:5000/post/action02
{
  "receivedType": "application/json",
  "body": {
    "name": "martin",
    "age": 42,
    "children": [
      "léa",
      "tom"
    ]
  }
}

Las comillas del JSON van precedidas de un [\] para evitar que termine la cadena del comando; en [Linux] y [macOS], también se puede encerrar el JSON entre apóstrofos: [-d '{"name": "martin"}']. A diferencia de los campos de formulario, el JSON transporta tipos de datos: la edad ya es un entero. Un cuerpo que no es JSON, seguido de un JSON mal formado:

curl -i -d "name=martin" http://localhost:5000/post/action02
curl -i -H "Content-Type: application/json" -d "{\"name\": " http://localhost:5000/post/action02
HTTP/1.1 415 UNSUPPORTED MEDIA TYPE
Content-Type: text/html; charset=utf-8
Content-Length: 215

<!doctype html>
<html lang=en>
<title>415 Unsupported Media Type</title>
<h1>Unsupported Media Type</h1>
<p>Did not attempt to load JSON data because the request Content-Type was not &#39;application/json&#39;.</p>
HTTP/1.1 400 BAD REQUEST
Content-Type: text/html; charset=utf-8
Content-Length: 163

<!doctype html>
<html lang=en>
<title>400 Bad Request</title>
<h1>Bad Request</h1>
<p>Failed to decode JSON object: Expecting value: line 1 column 10 (char 9)</p>

Un solo campo, y luego la misma URL solicitada mediante GET:

curl -d "name=jean%20dupont" http://localhost:5000/post/action03
curl -i "http://localhost:5000/post/action03?name=martin"
name = [jean dupont]
HTTP/1.1 405 METHOD NOT ALLOWED
Content-Type: text/html; charset=utf-8
Allow: POST, OPTIONS
Content-Length: 153

<!doctype html>
<html lang=en>
<title>405 Method Not Allowed</title>
<h1>Method Not Allowed</h1>
<p>The method is not allowed for the requested URL.</p>

La URL existe, pero no para el método GET: [Flask] devuelve un 405 (*Method Not Allowed*), y su encabezado [Allow] enumera los métodos aceptados ([OPTIONS] es manejado automáticamente por [Flask] para cualquier ruta). Por último, el modelo vinculado a los campos del formulario, primero válido y luego no válido:

curl -d "name=martin&age=42&title=Mr" http://localhost:5000/post/action04
curl -d "name=m&age=200" http://localhost:5000/post/action04
{
  "person": {
    "name": "martin",
    "age": 42,
    "title": "Mr",
    "email": null
  },
  "valid": true,
  "errors": []
}
{
  "person": null,
  "valid": false,
  "errors": [
    "age: the value must be less than or equal to 150",
    "name: 2 character(s) at least",
    "title: the field is required"
  ]
}

3.6. Ejemplo 12: Enlace (binding) y validación personalizados

Los tipos estándar no siempre son suficientes. Este ejemplo muestra tres maneras de ampliar el enlace (binding) y la validación:

  • un convertidor de ruta: una fecha en formato francés, [23-09-2026], en la ruta de la URL;
  • un decorador que proporciona a la acción un parámetro que no proviene de la URL, sino de un encabezado HTTP;
  • tipos “personalizados” para [Pydantic]: una restricción (sin espacios) y una conversión (una fecha [dd/mm/yyyy]).
1
2
3
4
5
6
7
8
12-custom-binding/
├── app.py
├── binding/
│   ├── date_fr.py
│   ├── language.py
│   └── types.py
└── controllers/
    └── examples.py

3.6.1. Un convertidor de ruta: binding/date_fr.py

En el ejemplo 02, nos encontramos con los convertidores de [Werkzeug]: [<int:id>] acepta solo un entero y lo convierte. Es posible escribir convertidores nuevos.

# binding/date_fr.py: una fecha francesa "23-09-2026" en la ruta de la URL
from datetime import date, datetime

from werkzeug.routing import BaseConverter, ValidationError


# un CONVERTIDOR de Werkzeug (la biblioteca sobre la que se construye Flask):
# decide si un trozo de la ruta es adecuado, y lo convierte en un objeto Python
class DateFrConverter(BaseConverter):
    # la expresión regular del trozo de ruta: dd-mm-aaaa
    regex = r"\d{2}-\d{2}-\d{4}"

    # texto de la ruta -> objeto date
    def to_python(self, value: str) -> date:
        try:
            # strptime verifica que la fecha exista: "31-02-2026" se rechaza
            return datetime.strptime(value, "%d-%m-%Y").date()
        except ValueError:
            # la ruta no coincide: Flask busca otra ruta y luego responde 404
            raise ValidationError()

    # objeto date -> texto de la ruta (lo usa url_for)
    def to_url(self, value: date) -> str:
        return value.strftime("%d-%m-%Y")
  • línea 9: un convertidor es una clase que hereda de [BaseConverter];
  • línea 11: el atributo [regex] es una expresión regular que describe el formato del segmento de ruta aceptado: [\d] designa un dígito, [{2}] designa la repetición del elemento anterior, en este caso, dos dígitos. El prefijo [r] en la cadena (*raw string*) impide que [Python] interprete [\]. El enrutamiento solo intenta usar este convertidor en un segmento de ruta con esta forma;
  • líneas 14–20: [to_python] transforma el texto de la ruta en un objeto [Python], en este caso un [date]. [datetime.strptime] (*string parse time*) analiza una cadena según un formato específico: [%d] para el día, [%m] para el mes y [%Y] para el año de cuatro dígitos; [.date()] conserva la fecha sin la hora. [strptime] verifica que la fecha exista: [31-02-2026] tiene el formato correcto, pero lanza un [ValueError]. El convertidor lanza entonces la excepción [ValidationError] de [Werkzeug] (que no debe confundirse con la de [Pydantic]): para el enrutamiento, la ruta no coincide con la URL, lo que producirá un error 404 si ninguna otra ruta coincide con ella;
  • líneas 23–24: la operación inversa, utilizada por [url_for] para construir una URL a partir de una fecha. [strftime] (*string format time*) da formato a una fecha.

El convertidor se registra en [app.py]:

# app.py: la aplicación del ejemplo 12
from flask import Flask

from controllers.examples import examples
from binding.date_fr import DateFrConverter


def create_app():
    app = Flask(__name__)
    # un convertidor de variable de ruta, con el nombre [datefr]: las rutas
    # ahora pueden escribir <datefr:day>, como <int:id>
    app.url_map.converters["datefr"] = DateFrConverter
    app.register_blueprint(examples)
    return app


if __name__ == "__main__":
    create_app().run(port=5000, debug=True)
  • Línea 12: [app.url_map] es la tabla de enrutamiento de la aplicación; su diccionario, [converters], asocia un nombre a cada convertidor ([int], [path]...). Añadimos el nuestro, con el nombre [datefr]. La entrada debe preceder a las de los blueprints que lo utilizan.

3.6.2. Un parámetro proporcionado por un decorador: binding/language.py

Una acción [Flask] recibe como parámetros las variables de la ruta, y nada más. Para proporcionarle información adicional, podemos decorar la acción: el decorador reemplaza la acción por una función que calcula la información y luego llama a la acción pasándole esa información.

# binding/language.py: un decorador que PROPORCIONA un parámetro a la acción
from functools import wraps

from flask import request


# @with_language, colocado en una acción, le pasa el parámetro [language], leído del
# encabezado "Accept-Language: fr-FR,fr;q=0.9,en;q=0.8" -> "fr"
def with_language(action):
    # wraps: la función producida conserva el nombre de la acción (Flask lo usa
    # para nombrar la ruta)
    @wraps(action)
    def action_with_language(*args, **kwargs):
        # request.accept_languages: el encabezado ya analizado por Werkzeug;
        # best_match: el idioma preferido del navegador entre los ofrecidos
        kwargs["language"] = request.accept_languages.best_match(["fr", "en"], default="fr")
        return action(*args, **kwargs)

    return action_with_language
  • Línea 9: un decorador es una función que recibe una función (en este caso, la acción) y devuelve otra función (véase el ejemplo 01). Escribir [@with_language] encima de [def hello(...)] equivale a escribir, después de la definición, [hello = with_language(hello)];
  • Línea 13: la función que reemplazará a la acción. [*args] recibe los parámetros posicionales en una tupla, y [**kwargs] (*keyword arguments*) recibe los parámetros con nombre en un diccionario. Así es como [Flask] pasa las variables de la ruta ([id=3]): la función las recibe sin necesidad de conocerlas;
  • línea 16: se agrega un parámetro con nombre, [language]. [request.accept_languages] es el encabezado de solicitud [Accept-Language], que ya fue analizado por [Werkzeug]. Aquí el navegador especifica los idiomas del usuario, por orden de preferencia: [fr-FR,fr;q=0.9,en;q=0.8] (el coeficiente [q] mide la preferencia, en una escala de 0 a 1). [best_match] selecciona, entre los idiomas que ofrece la aplicación, el que prefiere el usuario, o el valor [default] si ninguno es adecuado;
  • línea 17: la llamada a la acción original, con los parámetros recibidos y el nuevo. Las notaciones [*args] y [**kwargs] desempaquetan esta vez la tupla y el diccionario en parámetros;
  • línea 12: la función [action_with_language] conserva el nombre ([__name__]) y la documentación de la acción. Esto es esencial aquí: [Flask] nombra cada ruta con el nombre de su función (el [hello] de [url_for("examples.hello")]), y se negaría a registrar dos rutas con el mismo nombre, [action_with_language], si dos acciones usaran el decorador.

Veremos este enfoque a lo largo del curso: los decoradores [@login_required] y [@role_required] del capítulo sobre autenticación se construyen de la misma manera.

3.6.3. Tipos “personalizados” para Pydantic: binding/types.py

# binding/types.py: tipos "caseros" para los modelos Pydantic
from datetime import date, datetime
from typing import Annotated

from pydantic import AfterValidator, BeforeValidator


# una restricción "casera": la cadena no debe contener espacios.
# La función recibe el valor YA convertido a str; lo devuelve, o lanza
# un ValueError cuyo mensaje pasa a ser el del error de validación
def no_space(value: str) -> str:
    if " " in value:
        raise ValueError("the field must not contain a space")
    return value


# Annotated: el tipo str, completado con una verificación ejecutada DESPUÉS de la
# conversión. NoSpace se usa entonces como un tipo ordinario
NoSpace = Annotated[str, AfterValidator(no_space)]


# una conversión "casera": "23/09/2026" -> date(2026, 9, 23), ejecutada ANTES de
# la validación del tipo date
def date_fr(value):
    if isinstance(value, str):
        try:
            return datetime.strptime(value, "%d/%m/%Y").date()
        except ValueError:
            raise ValueError(f"[{value}] is not a valid dd/mm/yyyy date")
    return value


DateFr = Annotated[date, BeforeValidator(date_fr)]
  • Líneas 11–14: una función de validación: recibe como entrada el valor del campo, lo devuelve si es válido y, en caso contrario, lanza un [ValueError] . El mensaje de la excepción se convierte en el mensaje del error de validación;
  • línea 19: el tipo [NoSpace] es el tipo [str], anotado con [AfterValidator(no_space)]: [Pydantic] llamará a la función después de verificar (y, si es necesario, convertir) el valor a [str]. Esto permite definir, una sola vez, un tipo que puede reutilizarse en todos los modelos, igual que un tipo ordinario;
  • Líneas 24–30: una función de conversión. El tipo ***[date] de *[Pydantic] acepta cadenas en el formato internacional, ***[2026-09-23]; nosotros queremos el formato francés, ***[23/09/2026]. La función recibe el valor sin procesar : si es una cadena, la convierte a [date]. Cualquier otro valor (un [date]** ya construido, por ejemplo) se devuelve tal cual;
  • línea 33: [BeforeValidator]: la función se llama antes de la validación del tipo [date], que por lo tanto recibe un [date] ya construido.

3.6.4. El controlador: controllers/examples.py

# controllers/examples.py: binding y validación personalizados
from datetime import date

from flask import Blueprint, request, url_for
from pydantic import BaseModel, ValidationError

from binding.language import with_language
from binding.types import DateFr, NoSpace

examples = Blueprint("examples", __name__, url_prefix="/examples")


# /examples/schedule/23-09-2026: un convertidor de ruta personalizado (vea app.py)
@examples.get("/schedule/<datefr:day>")
def schedule(day: date):
    # url_for usa el método to_url del convertidor: date -> "23-09-2026"
    return f"schedule for the day [{day}], of type {type(day).__name__}, " \
           f"URL: {url_for('examples.schedule', day=day)}"


# /examples/hello: un parámetro que no proviene de la URL, sino de un encabezado,
# proporcionado por el decorador @with_language
@examples.get("/hello")
@with_language
def hello(language: str):
    return "Hello!" if language == "en" else "Bonjour !"


# el modelo de la búsqueda: dos tipos "caseros"
class SearchModel(BaseModel):
    keyword: NoSpace | None = None
    since: DateFr | None = None


# /examples/search?keyword=flask&since=01/09/2026
@examples.get("/search")
def search():
    model = SearchModel.model_validate(request.args.to_dict())
    return f"search for [{model.keyword}] since [{model.since}]"


# --------------------------------------------------------------- errores
# errorhandler de un BLUEPRINT: convierte una excepción lanzada por una de SUS
# acciones en una respuesta (el mismo decorador en la aplicación se aplica a todas)
@examples.errorhandler(ValidationError)
def validation(e: ValidationError):
    # el mensaje del primer error, sin el prefijo "Value error, " de Pydantic
    message = e.errors()[0]["msg"].removeprefix("Value error, ")
    return message, 400, {"Content-Type": "text/plain; charset=utf-8"}
  • Líneas 14–18: la variable de ruta [day] usa el convertidor [datefr]: la acción recibe un [date]. [url_for] construye la URL de esta misma acción a partir de la fecha, mediante el método [to_url] del convertidor. El separador [\] al final de la línea continúa la instrucción en la línea siguiente; dos cadenas literales consecutivas se concatenan;
  • Líneas 23–25: el orden de los decoradores importa. Se aplican de abajo hacia arriba: [@with_language] primero transforma la acción y luego [@examples.get] guarda la función transformada en el blueprint. En el orden inverso, el blueprint guardaría la acción original, y el parámetro [language] nunca se proporcionaría;
  • líneas 30–32: un modelo que usa los dos tipos “personalizados” como si fueran tipos ordinarios. Ambos campos son opcionales;
  • líneas 45–49: un manejador de excepciones, esta vez declarado en el blueprint: solo maneja las excepciones lanzadas por las acciones de este blueprint. [removeprefix] elimina el prefijo ["Value error, "] del mensaje, que [Pydantic] agrega a los mensajes de [ValueError]. La respuesta es una tupla de tres elementos: el cuerpo, el código y un diccionario de encabezados (véase el ejemplo 03), en este caso para una respuesta en texto sin formato.

3.6.5. Ejecución

El convertidor de ruta:

curl "http://localhost:5000/examples/schedule/23-09-2026"
curl -i "http://localhost:5000/examples/schedule/31-02-2026"
1
2
3
4
5
schedule for the day [2026-09-23], of type date, URL: /examples/schedule/23-09-2026
HTTP/1.1 404 NOT FOUND
Content-Type: text/html; charset=utf-8
Content-Length: 207
...

La fecha es mostrada por [Python] en en formato internacional (este es el resultado de convertir un [date] en cadena), pero la URL construida por [url_for] ha vuelto al formato francés. El 31 de febrero no existe: 404. Una fecha en formato internacional, [2026-09-23], no coincide con el patrón descrito por la expresión regular: también 404.

El decorador. La opción [-H] de [curl] establece el encabezado [Accept-Language]:

1
2
3
curl -H "Accept-Language: en-US,en;q=0.9,fr;q=0.8" http://localhost:5000/examples/hello
curl -H "Accept-Language: fr-FR,fr;q=0.9" http://localhost:5000/examples/hello
curl http://localhost:5000/examples/hello
1
2
3
Hello!
Bonjour !
Bonjour !

Sin un encabezado [Accept-Language] ([curl] no envía ninguno), se usa el idioma predeterminado. El capítulo sobre internacionalización retomará este tema, con la selección del idioma por parte del usuario.

Tipos “personalizados”:

1
2
3
4
5
curl "http://localhost:5000/examples/search?keyword=flask&since=01/09/2026"
curl "http://localhost:5000/examples/search"
curl -i "http://localhost:5000/examples/search?keyword=flask%20mvc"
curl "http://localhost:5000/examples/search?since=2026-09-01"
curl "http://localhost:5000/examples/search?since=31/02/2026"
1
2
3
4
5
6
7
8
9
search for [flask] since [2026-09-01]
search for [None] since [None]
HTTP/1.1 400 BAD REQUEST
Content-Type: text/plain; charset=utf-8
Content-Length: 34

the field must not contain a space
[2026-09-01] is not a valid dd/mm/yyyy date
[31/02/2026] is not a valid dd/mm/yyyy date

3.6.6. Conclusión

Resumamos los métodos de que dispone una acción para obtener su modelo:

Origen
Método
Variables de ruta
los parámetros de la acción, tipados por los convertidores ([<int:id>], [<datefr:day>])
Parámetros de la URL
[request.args]: [get] (junto con [type] y [default]), [getlist], [to_dict]
Campos de un formulario POST
[request.form], un [MultiDict], y un [request.args]
Cuerpo JSON
[request.get_json()]
Encabezados
[request.headers], y objetos ya analizados, como [request.accept_languages]
Conversión y validación
un modelo [Pydantic]: [model_validate], [ValidationError], [e.errors()]
Errores comunes
[@app.errorhandler] (toda la aplicación) o [@blueprint.errorhandler] (un blueprint)
Parámetro calculado
Un decorador que agrega un parámetro con nombre a la acción

Los formularios HTML, en cambio, requieren algo más que validación: deben mostrarse, volver a mostrarse con los datos ingresados por el usuario y los posibles errores, y protegerse contra solicitudes falsificadas. Este será el papel de [WTForms], que se tratará en el próximo capítulo, una vez presentadas las vistas.