Django signals भनेको के हो?

Question

Accepted Answer

**Signals** Django को observer pattern को कार्यान्वयन हो — यसले गर्दा विभिन्न senders ले receivers को समूहलाई सूचित गर्न सक्छन् जब विशिष्ट **events** घटन्छ (जस्तै मोडल save वा delete हुनु)। यसले **decoupled** कोड सक्षम गर्छ: अनुप्रयोगको एक भाग अर्कोमा घटनाहरूमा प्रतिक्रिया गर्छ बिना प्रत्यक्ष युग्मन।

## Common built-in signals

```text
pre_save / post_save      → before / after a model instance is saved
pre_delete / post_delete  → before / after a model instance is deleted
m2m_changed               → a ManyToMany relationship changed
request_started / finished→ request lifecycle
user_logged_in / out      → authentication events
```

## Connecting a receiver to a signal

```python
from django.db.models.signals import post_save
from django.dispatch import receiver

# automatically create a Profile whenever a User is created
@receiver(post_save, sender=User)
def create_profile(sender, instance, created, **kwargs):
    if created:                          # only on creation, not every save
        Profile.objects.create(user=instance)
```

`@receiver` decorator एक फंक्शनलाई निर्दिष्ट sender को लागि signal सँग जोड्छ। जब `User` save हुन्छ, Django यो फंक्शन कल गर्छ — यहाँ, सम्बन्धित `Profile` स्वचालित रूपमा बनाउँदा। `created` flag ले सृजन र अपडेटहरू अलग गर्छ।

## A typical use case

```python
@receiver(post_save, sender=Order)
def send_order_confirmation(sender, instance, created, **kwargs):
    if created:
        send_email(instance.customer.email, "Order confirmed")
# the Order-creation code doesn't need to know about emails → decoupled
```

अर्डर-सिर्जना गर्ने कोड अर्डरहरूमा केन्द्रित रहन्छ; ईमेल तर्क अलग रहन्छ र घटनामा प्रतिक्रिया गर्छ — चिन्ताहरूलाई decoupled राख्दै।

## When signals are useful

```text
✓ Reacting to model events from a DIFFERENT app/module (decoupling)
✓ Auto-creating related objects (Profile on User creation)
✓ Cache invalidation, search-index updates, audit logging on save/delete
✓ Cross-cutting reactions you don't want to embed in the core logic
```

## The important caveat: signals can hurt clarity

```python
# ⚠️ signals create IMPLICIT, "action at a distance" behavior:
# saving an Order triggers an email somewhere else — not obvious from the save call.
# This can make code HARDER to follow and debug.
```

```text
When to PREFER explicit code over signals:
  ✗ If the logic clearly belongs in the same flow → call it directly (more readable)
  ✗ Overusing signals → hidden, hard-to-trace behavior, debugging difficulty
  ✓ A common alternative: override the model's save() method, or use a service function,
    for logic tightly coupled to the operation
Use signals mainly for genuine DECOUPLING (reacting across app boundaries), not as
a default for all post-save logic.
```

## किन यो महत्त्वपूर्ण छ

Signals Django को उपयोगी विशेषता हो **decoupling** कोडको लागि — अनुप्रयोगको विभिन्न भागहरूलाई घटनाहरूमा (मोडल saves/deletes, auth events) प्रतिक्रिया गर्न दिन्छ प्रत्यक्ष निर्भरताहरू बिना, जो सम्बन्धित वस्तुहरू स्वचालित रूपमा बनाउनु, cache invalidation, audit logging, र app boundaries भर घटनाहरूमा प्रतिक्रिया गर्नु जस्ता cross-cutting concerns को लागि मूल्यवान।

यसलाई बुझ्नु महत्त्वपूर्ण छ तिनीहरू उपयोग गर्न अनुमति दिने (*उपयोग गरी*) र अस्तित्वमा रहेको codebases मा यसलाई चिन्न (यो "यो किन घटन्यो?" भ्रमको साधारण स्रोत हो) दुवै को लागि।
"]]}तथापि, signals लाई महत्त्वपूर्ण विषय बनाउने कुरा **nuanced judgment हो तिनीहरू कहिले प्रयोग गर्ने बारे**: जबकि यसले elegant decoupling सक्षम गर्छ, यसले **implicit,