Il posto giusto per conservare il mio file signal.py in un progetto Django

Sulla base della documentazione di Django che stavo leggendo, sembra che signals.pynella cartella dell'app sia un buon punto di partenza, ma il problema che sto affrontando è che quando creo segnali per pre_savee provo a importare la classe dal modello, è in conflitto con il importnel mio modello.

# models.py

from django.contrib.auth.models import User
from django.db import models
from django.utils.translation import gettext as _
from signals import *

class Comm_Queue(CommunicatorAbstract):
    queue_statuses = (
        ('P', _('Pending')),
        ('S', _('Sent')),
        ('E', _('Error')),
        ('R', _('Rejected')),
    )
    status          = models.CharField(max_length=10, db_index=True, default='P')
    is_html         = models.BooleanField(default=False)
    language        = models.CharField(max_length=6, choices=settings.LANGUAGES)
    sender_email    = models.EmailField()
    recipient_email = models.EmailField()
    subject         = models.CharField(max_length=100)
    content         = models.TextField()

# signals.py

from django.conf import settings
from django.db.models.signals import pre_save
from django.dispatch import receiver
from models import Comm_Queue

@receiver(pre_save, sender=Comm_Queue)
def get_sender_email_from_settings(sender, **kwargs):
    obj=kwargs['instance']
    if not obj.sender_email:
        obj.sender_email='%s' % settings.ADMINS[0][1]

Questo codice non verrà eseguito perché importa Comm_Queueall'interno signals.pye importa anche i segnali all'interno models.py.

Qualcuno può consigliarmi su come ho potuto superare questo problema?

Saluti

Risposta originale, per Django <1.7:

Puoi registrare i segnali importando signals.pynel __init__.pyfile dell'app :

# __init__.py
import signals

Ciò consentirà di importare models.pyda signals.pysenza errori di importazione circolare.

Un problema con questo approccio è che incasina i risultati di copertura se utilizzi coverage.py.

Discussione correlata

Modifica: per Django> = 1.7:

Da quando è stato introdotto AppConfig, il modo consigliato di importare i segnali è nella sua init()funzione. Vedi la risposta di Eric Marcos per maggiori dettagli.

Se stai usando Django <= 1.6 ti consiglio la soluzione Kamagatos: importa semplicemente i tuoi segnali alla fine del modulo dei tuoi modelli.

Per le versioni future di Django (> = 1.7), il modo consigliato è importare il modulo dei segnali nella funzione config ready () della tua app :

my_app/apps.py

from django.apps import AppConfig

class MyAppConfig(AppConfig):
    name = 'my_app'

    def ready(self):
        import my_app.signals

my_app/__init__.py

default_app_config = 'my_app.apps.MyAppConfig'

Per risolvere il tuo problema devi solo importare signal.py dopo la definizione del tuo modello. È tutto.

Ho anche inserito i segnali nel file signal.py e ho anche questo frammento di codice che carica tutti i segnali:

# import this in url.py file !

import logging

from importlib import import_module

from django.conf import settings

logger = logging.getLogger(__name__)

signal_modules = {}

for app in settings.INSTALLED_APPS:
    signals_module = '%s.signals' % app
    try:
        logger.debug('loading "%s" ..' % signals_module)
        signal_modules[app] = import_module(signals_module)
    except ImportError as e:
        logger.warning(
            'failed to import "%s", reason: %s' % (signals_module, str(e)))

Questo è per il progetto, non sono sicuro che funzioni a livello di app.

Nelle vecchie versioni di Django andrebbe bene mettere i segnali su __init__.pyo forse su models.py(anche se alla fine i modelli saranno troppo grandi per i miei gusti).

Con Django 1.9, credo sia meglio posizionare i segnali su un signals.pyfile e importarli con il apps.py, dove verranno caricati dopo aver caricato il modello.

apps.py:

from django.apps import AppConfig


class PollsConfig(AppConfig):
    name = 'polls'

    def ready(self):
        from . import signals  # NOQA

Puoi anche dividere i tuoi segnali su signals.pye handlers.pyin un'altra cartella all'interno del tuo modello con il nome signals, ma per me è solo un'ingegneria. Dai un'occhiata a Posizionamento dei segnali

Immagino che tu lo stia facendo in modo che i tuoi segnali siano registrati, in modo che vengano trovati da qualche parte. Normalmente metto i miei segnali in un file models.py.

Questo vale solo se hai i tuoi segnali in un signals.pyfile separato

Sono completamente d'accordo con la risposta di @EricMarcos ma va detto che la documentazione di django consiglia esplicitamente di non utilizzare la variabile default_app_config (anche se non è sbagliata). Per le versioni attuali, il modo corretto sarebbe:

my_app / apps.py

from django.apps import AppConfig

class MyAppConfig(AppConfig):
    name = 'my_app'

    def ready(self):
        import my_app.signals

settings.py

(Assicurati di non avere solo il nome della tua app nelle app installate, ma invece il percorso relativo alla tua AppConfig)

INSTALLED_APPS = [
    'my_app.apps.MyAppConfig',
    # ...
]

Un'alternativa è importare le funzioni di callback da signals.pye collegarle in models.py:

signal.py

def pre_save_callback_function(sender, instance, **kwargs):
    # Do stuff here

model.py

# Your imports here
from django.db.models.signals import pre_save
from yourapp.signals import pre_save_callback_function

class YourModel:
    # Model stuff here
pre_save.connect(pre_save_callback_function, sender=YourModel)

Ps: l'importazione YourModelin signals.pycreerà una ricorsione; usa sender, invece.

Ps2: il nuovo salvataggio dell'istanza nella funzione di callback creerà una ricorsione. Puoi creare un argomento di controllo nel .savemetodo per controllarlo.