How to Create and Use Django Signals for Automatic Actions on Model Save

In Django, signals allow you to attach custom behavior to specific actions within the framework, such as saving or deleting objects. Signals can be incredibly useful when you need to automatically perform actions before or after saving an object, such as validating data, adjusting fields, or running additional processes.

In this guide, we will walk you through how to create and use Django signals — specifically, the pre_save and post_save signals — to automatically handle tasks when creating or updating model instances.

What Are Django Signals?

Django signals are a way to allow certain actions to be triggered when specific events happen. Signals help decouple your application logic, so different parts of your application can react to certain actions without being tightly coupled.

For example, you can use signals to perform actions before an object is saved to the database, after it is saved, before it is deleted, or after it is deleted.

Types of Signals in Django

The most commonly used signals when working with models are:

  1. pre_save: This signal is triggered before an instance of a model is saved. It's useful for modifying or validating an object before saving it.

  2. post_save: This signal is triggered after an instance has been saved to the database. It's ideal for performing follow-up actions that should occur after saving the object, like sending an email or updating related records.

  3. pre_delete: This signal is triggered before an instance of a model is deleted from the database.

  4. post_delete: This signal is triggered after an instance has been deleted from the database.

Use Case: Automatically Modify or Validate Fields Before and After Save

In this example, we will demonstrate how to use both the pre_save and post_save signals in Django:

  1. pre_save: Automatically adjust the price field before the model instance is saved.
  2. post_save: Perform a follow-up action, like logging that the item was saved.

Step-by-Step: Using Django Signals

1. Create Your Django Model

Let’s start by creating a model called Item. This model has fields like name, price, description, and is_active. We will work with the price field, automatically setting it to a minimum value before saving, and logging some information after saving.

from django.db import models

class Item(models.Model):
    name = models.CharField(max_length=255)
    price = models.DecimalField(max_digits=10, decimal_places=2)
    description = models.TextField(null=True, blank=True)
    is_active = models.BooleanField(default=True)

    def __str__(self):
        return self.name


2. Define the pre_save Signal

The pre_save signal will be triggered before an Item instance is saved. In this case, we will use it to ensure that the price field is never set below a minimum value (e.g., $1).

from django.db.models.signals import pre_save
from django.dispatch import receiver
from .models import Item

@receiver(pre_save, sender=Item)
def check_price(sender, instance, **kwargs):
    """Ensure the price is at least $1 before saving the item."""
    if instance.price < 1:
        instance.price = 1  # Set price to 1 if it's below $1


3. Define the post_save Signal

After the Item instance is saved, we will use the post_save signal to log some information (e.g., logging the creation of a new item).

from django.db.models.signals import post_save
from django.dispatch import receiver
from django.utils.timezone import now

@receiver(post_save, sender=Item)
def log_item_creation(sender, instance, created, **kwargs):
    """Log item creation after saving the item."""
    if created:  # This will only run when a new item is created
        print(f"New item created: {instance.name} with price {instance.price} on {now()}")


4. Connect the Signals

To connect the signals, create a signals.py file in your app and place your signal handlers there. Then, ensure that the signals are loaded when your app starts.

Here’s how you can organize it:

# core/signals.py
from django.db.models.signals import pre_save, post_save
from django.dispatch import receiver
from .models import Item
from django.utils.timezone import now

@receiver(pre_save, sender=Item)
def check_price(sender, instance, **kwargs):
    """Ensure the price is at least $1 before saving the item."""
    if instance.price < 1:
        instance.price = 1

@receiver(post_save, sender=Item)
def log_item_creation(sender, instance, created, **kwargs):
    """Log item creation after saving the item."""
    if created:
        print(f"New item created: {instance.name} with price {instance.price} on {now()}")


Then, ensure Django loads this signal by modifying the apps.py file of your app

# app_name/apps.py
from django.apps import AppConfig

class AppNameConfig(AppConfig):
    name = 'app_name'

    def ready(self):
        import app_name.signals  # Import the signals to register them


5. Test the Signals

Now, every time you create or update an Item object, the pre_save signal will ensure that the price is above $1, and the post_save signal will log the creation of the new item.

# Create a new item
new_item = Item.objects.create(
    name="Test Item",
    price=0.5,  # This will automatically be adjusted to 1
    description="This is a test item."
)

# The output will print the following in the console:
# New item created: Test Item with price 1.00 on <current time>

print(new_item.price)  # This will print '1.00', not '0.5'


Why Use Signals in Django?

Django signals provide a clean and powerful way to automatically handle common tasks, such as data validation, logging, or performing follow-up actions. Here are some benefits of using Django signals:

  1. Automatic Actions: You can set up automatic tasks, like modifying or validating fields, without manually handling them each time in views or serializers.

  2. Separation of Concerns: Signals help decouple logic by allowing you to define actions in different places. For example, you can handle model field adjustments and logging independently of the model itself.

  3. Follow-Up Actions: The post_save signal is useful for tasks that should occur after a record is saved, such as sending emails, updating related records, or logging activities.

  4. Cleaner Code: Using signals helps keep your codebase clean by abstracting away repetitive logic. This makes your views and models easier to maintain.

Conclusion

Django signals provide an elegant way to automatically handle actions before and after saving model instances. In this guide, we demonstrated how to use both the pre_save and post_save signals to ensure the price field is adjusted before saving and to log the creation of new Item instances after they are saved.

By using Django signals, you can reduce redundancy, keep your codebase clean, and automate many common tasks in a modular way. Whether you're modifying fields, sending notifications, or updating related records, signals can simplify your development process and improve the efficiency of your Django projects.