Django సిగ్నల్‌లు అంటే ఏమిటి?

Question

Accepted Answer

**సిగ్నల్‌లు** Django యొక్క observer pattern అమలు — కొన్ని పంపిణీదారులు నిర్దిష్ట **events** సంభవించినప్పుడు (ఒక model సేవ్ చేయబడినప్పుడు లేదా తొలగించబడినప్పుడు) రిసీవర్‌ల సమితిని నోటిఫై చేయడానికి అనుమతిస్తాయి. అవి **decoupled** కోడ్‌ను ప్రారంభం చేస్తాయి: యాప్ యొక్క ఒక భాగం ఇతర భాగంలోని ఈవెంట్‌లకు ప్రత్యక్ష కపలింగ్ లేకుండా ప్రతిక్రియ చేస్తుంది.

## సాధారణ built-in సిగ్నల్‌లు

```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
```

## రిసీవర్‌ను సిగ్నల్‌కు కనెక్ట్ చేయడం

```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` డెకోరేటర్ నిర్దిష్ట పంపిణీదారు కోసం ఫంక్షన్‌ను సిగ్నల్‌కు కనెక్ట్ చేస్తుంది. `User` సేవ్ చేయబడినప్పుడు, Django ఈ ఫంక్షన్‌ను కాల్ చేస్తుంది — ఇక్కడ, సంబంధిత `Profile` ను స్వయంచాలకంగా సృష్టించడం. `created` ఫ్లాగ్ క్రియేషన్‌ను అప్‌డేట్‌ల నుండి వేరు చేస్తుంది.

## సాధారణ 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 ఉంచడం.

## సిగ్నల్‌లు ఉపయోగకరమైనప్పుడు

```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
```

## ముఖ్యమైన హెచ్చరిక: సిగ్నల్‌లు స్పష్టత్వానికి హాని చేయవచ్చు

```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.
```

## దీన్ని ఎందుకు విషయం

సిగ్నల్‌లు **decoupling** కోడ్ కోసం ఉపయోగకరమైన Django ఫీచర్ — యాప్‌లికేషన్ యొక్క వివిధ భాగాలు (model saves/deletes, auth events) ఈవెంట్‌లకు ప్రత్యక్ష డిపెండెన్సీలు లేకుండా ప్రతిక్రియ చేయడానికి అనుమతిస్తుంది, ఇది auto-creating సంబంధిత objects, cache invalidation, audit logging, మరియు app boundaries అంతటా ఈవెంట్‌లకు ప్రతిక్రియ చేయడం వంటి cross-cutting concerns కోసం విలువైనది.

ాలు అర్థం చేసుకోవడం వాటిని సరిగ్గా *ఉపయోగించడం* కోసం మరియు ఇప్పటికే ఉన్న codebases లో వాటిని గుర్తించడం కోసం ముఖ్యమైనది (అవి "ఇది ఎందుకు జరిగింది?" గందరగోళం యొక్క సాధారణ మూలం).
ac్టికల్ Django డెవెలపర్‌లు ఈ ట్రేడ్‌ఆఫ్‌ను అర్థం చేసుకుంటారు — *నిజమైన* decoupling కోసం సిగ్నల్‌లను ఉపయోగించడం (module/app boundaries అంతటా ఈవెంట్‌లకు ప్రతిక్రియ చేయడం నీరు మూలానికి కపలింగ్ చేయకూడదు) **స్పష్టమైన కోడ్** కు ఆదరణ చేయడం (లాజిక్‌ను నేరుగా కాల్ చేయడం, `save()` ను అవర్డ్‌ చేయడం, లేదా service functions ఉపయోగించడం) లాజిక్ ఒకే ప్రవాహానికి స్పష్టంగా చెందినప్పుడు, ఎందుకంటే స్పష్టమైన కోడ్ మరింత చదవదగినది మరియు traceableని ఉంటుంది.

సిగ్నల్‌లు ఎలా పనిచేస్తాయో తెలుసుకోవడం (connecting receivers, `created` flag, సాధారణ సిగ్నల్‌లు), వాటి సరైన use cases, మరియు కీలకంగా **వాటిని ఎప్పుడు ఉపయోగించకూడదు** (hidden, hard-to-debug behavior ను తప్పించడం) ఆచరణాత్మక, అనుభవం కలిగిన అవగాహనను ప్రతిబింబిస్తుంది ఇది నిర్వహణీయమైన Django కోడ్ రాయే డెవెలపర్‌లను సిగ్నల్‌లను ఎక్కువగా ఉపయోగించే మరియు tangled, opaque applications సృష్టించే వారి నుండి వేరు చేస్తుంది.