Django signals are a powerful feature that allows decoupled applications to get notified when certain actions occur elsewhere in the framework. They provide a way to execute some code when a specific event happens, such as saving a model instance or user login.

1. Signal: A signal is a message that is sent when a specific event occurs.
2. Sender: The sender is the entity that sends the signal.
3. Receiver: The receiver is a function or method that gets called when the signal is sent.
4. Dispatcher: The dispatcher is responsible for connecting senders to receivers and sending signals.

• pre_save and post_save: Sent before or after a model's save() method is called.
• pre_delete and post_delete: Sent before or after a model's delete() method is called.
• m2m_changed: Sent when a ManyToManyField is changed.
• request_started and request_finished: Sent when a request starts or finishes.
• user_logged_in and user_logged_out: Sent when a user logs in or out.

Let's create a practical example to understand how Django signals work. We will create a signal that logs a message every time a new user is created.

1. Create a Django Project and App

   First, create a new Django project and app if you haven't already:

   django-admin startproject myproject
   cd myproject
   python manage.py startapp myapp
   

2. Define the Signal Receiver

   In your myapp directory, create a new file called signals.py and define a receiver function:

   # myapp/signals.py
   from django.db.models.signals import post_save
   from django.contrib.auth.models import User
   from django.dispatch import receiver
   import logging
   
   logger = logging.getLogger(__name__)
   
   @receiver(post_save, sender=User)
   def user_created(sender, instance, created, **kwargs):
       if created:
           logger.info(f'New user created: {instance.username}')
   

3. Connect the Signal

   You need to ensure that the signal is connected when the app is ready. Modify the apps.py file in your myapp directory:

   # myapp/apps.py
   from django.apps import AppConfig
   
   class MyappConfig(AppConfig):
       default_auto_field = 'django.db.models.BigAutoField'
       name = 'myapp'
   
       def ready(self):
           import myapp.signals
   

4. Update __init__.py

   Ensure that the ready method is called by updating the __init__.py file in your myapp directory:

   # myapp/__init__.py
   default_app_config = 'myapp.apps.MyappConfig'
   

5. Test the Signal

   Create a new user to test if the signal works:

   from django.contrib.auth.models import User
   
   user = User.objects.create_user(username='testuser', password='password')
   

   Check your logs to see if the message "New user created: testuser" is logged.

Task: Create a signal that logs a message every time a user is deleted.

Solution:

1. Define the Signal Receiver

   # myapp/signals.py
   from django.db.models.signals import post_delete
   from django.contrib.auth.models import User
   from django.dispatch import receiver
   import logging
   
   logger = logging.getLogger(__name__)
   
   @receiver(post_delete, sender=User)
   def user_deleted(sender, instance, **kwargs):
       logger.info(f'User deleted: {instance.username}')
   

2. Connect the Signal

   Ensure the signal is connected in apps.py:

   # myapp/apps.py
   class MyappConfig(AppConfig):
       default_auto_field = 'django.db.models.BigAutoField'
       name = 'myapp'
   
       def ready(self):
           import myapp.signals
   

3. Test the Signal

   Delete a user to test if the signal works:

   user = User.objects.get(username='testuser')
   user.delete()
   

   Check your logs to see if the message "User deleted: testuser" is logged.

• Not Importing Signals: Ensure that your signals are imported in the ready method of your app's AppConfig.
• Incorrect Signal Connection: Double-check that the signal is connected to the correct sender.
• Logging Configuration: Ensure that your logging configuration is set up correctly to capture the log messages.

In this section, we learned about Django signals, their key concepts, and how to implement them in a Django project. We also covered practical examples and exercises to reinforce the concepts. Understanding signals is crucial for creating decoupled and maintainable Django applications. In the next section, we will dive into testing in Django, which is essential for ensuring the reliability and stability of your applications.