Trennen Sie Signale für Modelle und wieder in django

Muss ich machen sparen Sie mit einem Modell, aber ich muss trennen, einige Empfänger der Signale, bevor Sie es speichern.

Ich meine,

Habe ich ein Modell:

class MyModel(models.Model):
    ...

def pre_save_model(sender, instance, **kwargs):
    ...

pre_save.connect(pre_save_model, sender=MyModel)

und an anderer Stelle im code ich brauche so etwas wie:

a = MyModel()
...
disconnect_signals_for_model(a)
a.save()
...
reconnect_signals_for_model(a)

Da brauche ich in diesem Fall speichern Sie das Modell ohne ausführen der Funktion pre_save_model.

InformationsquelleAutor diegueus9 | 2010-02-05
  1. 31

    Für eine saubere und wiederverwendbare Lösung verwenden, können Sie einen context-manager:

    class temp_disconnect_signal():
    """ Temporarily disconnect a model from a signal """
    def __init__(self, signal, receiver, sender, dispatch_uid=None):
        self.signal = signal
        self.receiver = receiver
        self.sender = sender
        self.dispatch_uid = dispatch_uid

    def __enter__(self):
        self.signal.disconnect(
            receiver=self.receiver,
            sender=self.sender,
            dispatch_uid=self.dispatch_uid,
            weak=False
        )

    def __exit__(self, type, value, traceback):
        self.signal.connect(
            receiver=self.receiver,
            sender=self.sender,
            dispatch_uid=self.dispatch_uid,
            weak=False
        )

    Nun, können Sie etwas wie die folgende:

    from django.db.models import signals

from your_app.signals import some_receiver_func
from your_app.models import SomeModel

...
kwargs = {
    'signal': signals.post_save,
    'receiver': some_receiver_func,
    'sender': SomeModel, 
    'dispatch_uid': "optional_uid"
}
with temp_disconnect_signal(**kwargs):
    SomeModel.objects.create(
        name='Woohoo',
        slug='look_mom_no_signals',
    )

    Hinweis: Wenn Ihr signal-handler verwendet eine dispatch_uid Sie MUSS verwenden Sie die dispatch_uid arg.

    • Toll. Dies ist die eleganteste Lösung. Sie können die Wiederverwendung der Kontext-manager in mehreren teilen des Codes.
    • Eine kleine Warnung: weak=False ist nicht der Standard beim Anschluss von einem receiver zu einem signal.
    • weak ist veraltet Auch, die Menschen sollten sich bewusst sein, dass das deaktivieren eines Signals verhindern, dass all Instanzen von der Triggerung des Signals, nicht nur mit aktuellen Kontext (d.h. andere threads, wie Signale zu sein scheinen, thread-sichere), als vorgeschlagen here
    InformationsquelleAutor alukach
  2. 24

    Können Sie verbinden und trennen der Signale als Heuhaufen in RealTimeSearchIndex, das scheint mehr standard:

    from django.db.models import signals
signals.pre_save.disconnect(pre_save_model, sender=MyModel)
a.save()
signals.pre_save.connect(pre_save_model, sender=MyModel)
    • pre_savel_model ist das gleiche wie pre_save?
    InformationsquelleAutor qris
  3. 9

    Habe ich noch nicht getestet den folgenden code, aber es sollte funktionieren:

    from django.db.models.signals import pre_save


def save_without_the_signals(instance, *args, **kwargs):
    receivers = pre_save.receivers
    pre_save.receivers = []
    new_instance = instance.save(*args, **kwargs)
    pre_save.receivers = receivers
    return new_instance

    Wird es Stille Signale von alle Absenders aber nicht nur instance.__class__.

    Dieser version deaktiviert nur das Modell s-Signale:

    from django.db.models.signals import pre_save
from django.dispatch.dispatcher import _make_id


def save_without_the_signals(instance, *args, **kwargs):
    receivers = []
    sender_id = _make_id(instance.__class__)
    for index in xrange(len(self.receivers)):
        if pre_save.receivers[index][0][1] == sender_id:
            receivers.append(pre_save.receivers.pop(index))
    new_instance = instance.save(*args, **kwargs)
    pre_save.receivers.extend(receivers)
    return new_instance
    • Sie sollten wahrscheinlich wickeln Sie das speichern in einem try-block und der re-Anlage der Receiver in einen finally-Block. Sonst könnte man trennen der Signale für immer.
    InformationsquelleAutor muhuk
  4. 8

    Wenn Sie nur wollen, trennen Sie und schließen Sie ein benutzerdefiniertes signal, können Sie diesen code verwenden:

    def disconnect_signal(signal, receiver, sender):
    disconnect = getattr(signal, 'disconnect')
    disconnect(receiver, sender)

def reconnect_signal(signal, receiver, sender):
    connect = getattr(signal, 'connect')
    connect(receiver, sender=sender)

    Auf diese Weise können Sie diese:

    disconnect_signal(pre_save, pre_save_model, MyModel)
a.save()
reconnect_signal(pre_save, pre_save_model, MyModel)
    InformationsquelleAutor diegueus9
  5. 0

    Ich brauchte, um zu verhindern, dass bestimmte Signale von feuern während unittests also machte ich einen Dekorator basiert auf qris Antwort:

    from django.db.models import signals

def prevent_signal(signal_name, signal_fn, sender):
    def wrap(fn):
        def wrapped_fn(*args, **kwargs):
            signal = getattr(signals, signal_name)
            signal.disconnect(signal_fn, sender)
            fn(*args, **kwargs)
            signal.connect(signal_fn, sender)
        return wrapped_fn
    return wrap

    Verwendung ist einfach:

    @prevent_signal('post_save', my_signal, SenderClass)
def test_something_without_signal(self):
    # the signal will not fire inside this test
    • Deaktivierung der Signale während der tests irgendwie findet Sie den Zeitpunkt des Tests. Code flow sollte gleich bleiben, in Bezug auf Szenario. Wenn es code, den Sie nicht brauchen, um ausführen als Teil des Tests, dann verspotten Sie ist Ergebnis, nicht überspringen.
    • Wenn die umschlossene Funktion ist gedacht, um wieder etwas Wert, dein code wird nicht funktionieren. Sie sind verpflichtet, das Ergebnis der Funktion Wert in Ihrem Dekorateur.
    • es gibt Fälle, wo Sie vielleicht einen Abschnitt von test-code, erzeugt eine Menge von Testdaten. Normalerweise, wenn ein Benutzer erstellt, diese Modelle hätte es ein Nebeneffekt, aber Sie überspringen möchten, dass für jetzt. Ja, so könnte man spotten alle receiver-Funktionen, aber an diesem Punkt wird es deutlicher, wenn du Sie einfach deaktivieren Sie die Signale. Dann erstellen Sie eine normale integration test, wo die Signale wieder aktiviert wird.
    • Ich verstehe deinen Punkt, aber ich immer noch anderer Meinung. IMHO, ändern von code flow für Testzwecke ist eine schlechte Praxis, weil es leicht ist, zu vergessen, über die verschiedenen Wege den code nehmen können. speziell, verspotten, ist sehr explizit in der Natur und meiner Meinung nach mehr pythonic. Das heißt, wie bei jeder Regel, ich denke, es wird immer eine Ausnahme in der Regel gilt, dass die Gefahr besteht, dass die Ausnahme wird zur norm für die spätere Betreuer..
    InformationsquelleAutor Marcio Cruz
Schreibe einen Kommentar