Introducción al Sistema de Señales

El framework Django incorpora un sistema de señales basado en el patrón de diseño Observador (también conocido como Publicador-Suscriptor). Este mecanismo permite que componentes desacoplados reciban notificaciones automáticas cuando ocurren eventos específicos dentro del ciclo de vida de la aplicación. En términos prácticos, cuando una acción determinada se ejecuta, se emite una señal, y todas las funciones receptoras suscritas a dicha señal responden en consecuencia.

Señales Integradas en el Framework

Django expone una amplia variedad de señales nativas que cubren diferentes áreas del sistema. A continuación, se detallan las más relevantes clasificadas por su ámbito de acción:

Señales de Modelos (django.db.models.signals)

• pre_init / post_init: Se disparan antes y después de instanciar un modelo.
• pre_save / post_save: Ejecutadas justo antes y después de persistir un objeto en la base de datos.
• pre_delete / post_delete: Notifican la eliimnación inminente o completada de un registro.
• m2m_changed: Activada al modificar relaciones Muchos a Muchos (ManyToManyField).
• class_prepared: Se lanza cuando una clase de modelo ha sido completamente cargada y registrada.

Señales de Migración y Base de Datos

• pre_migrate / post_migrate: Emitidas durante la ejecución de comandos de migración de esquema.
• connection_created (django.db.backends.signals): Informa sobre el establecimiento de una nueva conexión a la base de datos.

Señales de Peticiones HTTP y Pruebas

• request_started / request_finished / got_request_exception (django.core.signals): Gestionan el ciclo de vida de las solicitudes web y la captura de excepciones.
• setting_changed / template_rendered (django.test.signals): Útiles durante la ejecución de suites de pruebas unitarias.

Suscripción a Señales Nativas

Para reaccionar a los eventos internos de Django, es necesario importar la señal deseada y vincularla a una función receptora. Existen dos enfoques principales para lograr esto:

Método Tradicional: connect()

Este enfoque suele implementarse en el archivo de configuración de la aplicación o en un módulo de inicialización.

from django.db.models.signals import post_save
import logging

# Configuración básica del logger
logger = logging.getLogger(__name__)

def registrar_actualizacion_modelo(sender, instance, created, **kwargs):
    """Registra un evento cada vez que se actualiza o crea un perfil de usuario."""
    if not created:
        logger.info(f"El perfil con ID {instance.id} ha sido modificado exitosamente.")

# Vinculación explícita de la señal
post_save.connect(registrar_actualizacion_modelo, sender='auth.User')

Método Moderno: Decorador @receiver

El uso de decoradores ofrece una sintaxis más limpia y es la práctica recomendada en la actualidad.

from django.db.models.signals import pre_delete
from django.dispatch import receiver
from myapp.models import Documento

@receiver(pre_delete, sender=Documento)
def limpiar_archivos_asociados(sender, instance, **kwargs):
    """Elimina los archivos físicos del sistema antes de borrar el registro en la BD."""
    if instance.archivo_adjunto:
        instance.archivo_adjunto.delete(save=False)

Creación y Emisión de Señales Personalizadas

Cuando las señales nativas no cubren un caso de uso específico de la lógica de negocio, es posible definir señales propias. Este proceso consta de tres fases: definición, suscripción y emisión.

1. Definición de la Señal

Se recomienda agrupar las señales personalizadas en un módulo dedicado, como signals.py.

import django.dispatch

# Definición de una señal para notificar la finalización de un proceso de pago
pago_procesado = django.dispatch.Signal()

Nota: En versiones recientes de Django, el argumento providing_args ha sido deprecado, por lo que los argumentos se pasan directamente como diccionarios al emitir la señal.

2. Suscripción del Receptor

La función que escuchará el evento debe ser registrada de la misma manera que con las señales nativas.

from django.dispatch import receiver
from .signals import pago_procesado

@receiver(pago_procesado)
def enviar_factura_por_email(sender, **kwargs):
    usuario = kwargs.get('usuario')
    monto = kwargs.get('monto_total')
    print(f"Enviando factura a {usuario.email} por un total de ${monto}.")

3. Emisión de la Señal

A diferencia de las señales integradas que Django dispara automáticamente, las señales personalizadas deben ser invocadas manualmente en el punto exacto del flujo de ejecución donde ocurre el evento.

from .signals import pago_procesado

def procesar_checkout(carrito, usuario):
    # Lógica de procesamiento de pago...
    transaccion_exitosa = True 
    
    if transaccion_exitosa:
        # Emisión manual de la señal
        pago_procesado.send(
            sender=carrito.__class__, 
            usuario=usuario, 
            monto_total=carrito.calcular_total()
        )