Django post_save la prévention de la récursivité sans écraser modèle save()

Il y a beaucoup de Débordement de Pile messages au sujet de la récursivité à l'aide de la post_save signal, dont les commentaires et les réponses sont en grande majorité: "pourquoi ne pas remplacer save()" ou save qui est seulement ouvert le feu sur created == True.

Eh bien, je crois qu'il y a une bonne affaire pour ne pas utiliser save() - par exemple, je suis l'ajout d'une application temporaire qui gère le traitement des commandes des données complètement séparée de notre modèle.

Le reste du cadre est au courant de la réalisation de l'application et l'utilisation de post_save crochets isolats toute l'exécution connexes code de notre modèle.

Si on laisse tomber l'accomplissement du service, rien à propos de notre code de base qui doit changer. Nous supprimons la réalisation de l'app, et c'est tout.

Donc, il y a aucune décent méthodes pour assurer la post_save signal n'est pas feu le gestionnaire de même deux fois?

  • Est-ce juste une rumination, ou vous avez une situation particulière où vous avez observé plusieurs tirs de la même gestionnaire pour un événement unique? E. g. save() feux post_save, ce qui entraîne une autre gestionnaire de save() le même objet, et donc de provoquer un autre tir de post_save?
  • oui, si votre post_save gestionnaire doit enregistrer l'expéditeur exemple, il va déclencher post_save de nouveau.
  • lire ici avec bulk_create vous pouvez enregistrer sans postsave et presave appel django docs
InformationsquelleAutor Yuji 'Tomita' Tomita | 2012-05-31
  1. 26

    Ce que vous pensez de cette solution?

    @receiver(post_save, sender=Article)
def generate_thumbnails(sender, instance=None, created=False, **kwargs):

    if not instance:
        return

    if hasattr(instance, '_dirty'):
        return

    do_something()

    try:
        instance._dirty = True
        instance.save()
    finally:
        del instance._dirty

    Vous pouvez également créer décorateur

    def prevent_recursion(func):

    @wraps(func)
    def no_recursion(sender, instance=None, **kwargs):

        if not instance:
            return

        if hasattr(instance, '_dirty'):
            return

        func(sender, instance=instance, **kwargs)

        try:
            instance._dirty = True
            instance.save()
        finally:
            del instance._dirty

    return no_recursion


@receiver(post_save, sender=Article)
@prevent_recursion
def generate_thumbnails(sender, instance=None, created=False, **kwargs):

    do_something()
    • Wow, assez simple, et pourtant, la solution intelligente, je pense que c'est la meilleure réponse à ce jour. Je souhaite qu'il y ait plus de commentaires sur ce.
    • Quelqu'un peut-il expliquer ce qui se passe dans cette solution? J'ai du mal à trouver toute la documentation pour l'_dirty drapeau
    • Mumford Il n'est pas un drapeau. Pour éviter la récursivité, nous pouvons définir l'attribut personnalisé avant instance.save() avec n'importe quel nom inutilisé comme _dirty. Ensuite, vérifiez si l'attribut existe et de briser la récursivité.Comme vous pouvez le voir nous avons mis _dirty attribut avant de sauvegarder le modèle et l'enlever lors de l'enregistrement est terminé.
    • Oups, bien sûr, mon mal; je devrais avoir regardé de plus près le reste de la fonction au lieu d'être pressé. Grâce 4ell
    • Il devrait être la réponse choisie.
    • Serait encore mieux avec un try...finally autour de l'appel à instance.save() pour s'assurer que del instance._dirty est toujours, même dans le cas, par exemple, de DatabaseError.
    • Est-ce à cause d'une condition de concurrence dans le cas de multiples appels à enregistrer avec une instance unique?
    • Il pourrait aider à montrer l'importation from functools import wraps

    InformationsquelleAutor xakdog
  2. 78

    vous pouvez utiliser la mise à jour au lieu de l'enregistrer dans le gestionnaire de signal

    quersyset.filtre(pk=instance.pk).mise à jour(....)
    • Hmm, mais que faire si certains autres gestionnaire de signal n'a save() au lieu de update()?
    • J'ai écrit cela dans mon post_save signal, mais il dit queryset n'est pas défini d'erreur.
    InformationsquelleAutor mossplix
  3. 34

    Ne débranchez pas les signaux. Si un nouveau modèle de même type est générée lorsque le signal est déconnecté de la fonction de gestionnaire ne sera pas déclenché. Les signaux sont globales à travers Django et plusieurs demandes peuvent être en cours d'exécution simultanément, de sorte que certains échoue tandis que d'autres exécutent leurs post_save gestionnaire.

    • C'est le point. Nous ne voulons pas que les signaux à exécuter pendant que nous sommes à l'intérieur de l'signaux. En outre, les signaux ne sont pas asynchrone. Découvrez stackoverflow.com/questions/11899088/...
    InformationsquelleAutor punkgode
  4. 24

    Je pense que la création d'un save_without_signals() méthode du modèle est plus explicite:

    class MyModel()
    def __init__():
        # Call super here.
        self._disable_signals = False

    def save_without_signals(self):
        """
        This allows for updating the model from code running inside post_save()
        signals without going into an infinite loop:
        """
        self._disable_signals = True
        self.save()
        self._disable_signals = False

def my_model_post_save(sender, instance, *args, **kwargs):
    if not instance._disable_signals:
        # Execute the code here.
    • Je l'aime. Une suggestion cependant: au lieu de l'annulation de la __init__, vous pourriez faire if not getattr(instance, '_disable_signals', False)
    • Est-ce "thread-safe"? Ce qui se passe si une sauvegarde est déclenché en même temps que un save_without_signals qui se passe?
    • Oui c'est thread-safe. Le _disable_signals propriété est local à chaque instance du modèle.
    • Comme c'. Depuis le deuxième appel de post enregistrer le signal ne fait rien, je l'espère, django va ajouter un paramètre dans une fonction de sauvegarde, de sorte que nous pouvons utiliser instance.save(send_signal=False).
    InformationsquelleAutor Rune Kaagaard
  5. 20

    Comment sur de déconnecter puis de reconnecter le signal à l'intérieur de votre post_save fonction:

    def my_post_save_handler(sender, instance, **kwargs):
    post_save.disconnect(my_post_save_handler, sender=sender)
    instance.do_stuff()
    instance.save()
    post_save.connect(my_post_save_handler, sender=sender)
post_save.connect(my_post_save_handler, sender=Order)
    • J'avais lu au sujet de cette méthode, et je me demandais si il y avait une solution plus propre... j'ai essayé en laissant les attributs de l'objet enregistré pour détecter si le gestionnaire a modifié l'objet une fois, mais il ne semble pas persister. D'autres options?
    • Je ne crois pas qu'il existe une solution propre.
    • ah - j'ai googlé à ma propre question et juste utilisé à nouveau 🙂 Merci!
    • ainsi, lorsque vous vous reconnectez, si vous avez le code ci-dessous la "post_save.se connecter" dans le my_post_save_save_handler, il va exécuter le reste du code?
    • c'est dangereux, alors que le signal n'est pas déconnecté des instances pourraient être sauvées et maintenant votre gestionnaire sera raté.
    • C'est en effet dangereux, alors je vais avec la mise à jour de la solution que j'ai utilisé avant sans problème.
    • Cela m'a aidé à nouveau et je ne peux pas +1 une fois de plus. La mise à jour de la solution ne fonctionne pas, lorsque vous voulez mettre à jour un ManyToMany champ.
    • Cette solution n'est pas thread-safe, les demandes simultanées peuvent potentiellement soit faussement ré-invoquer le signal pour le sauver appeler à l'intérieur de "my_post_save_handler" ou tort de ne pas invoquer la "my_post_save_handler" signal, en premier lieu, lorsqu'il est appelé à l'extérieur de ""my_post_save_handler". Ne recommande pas.
    • Non seulement ce n'est pas thread-safe, il manque aussi un try...finally. Doit faire de la (re)connect à l'intérieur de finally clause. Sans cela, si do_stuff ou save soulever une exception alors votre gestionnaire de rester coupé à jamais...

    InformationsquelleAutor dgel
  6. 4

    Vous devez utiliser queryset.mise à jour() à la place du Modèle.save (), mais vous devez prendre soin de quelque chose d'autre:

    Il est important de noter que lorsque vous l'utilisez, si vous voulez utiliser les nouveaux objets, vous devriez obtenir son objet nouveau, parce qu'il ne changera pas l'autonomie de l'objet, par exemple:

    >>> MyModel.objects.create(pk=1, text='')
>>> el = MyModel.objects.get(pk=1)
>>> queryset.filter(pk=1).update(text='Updated')
>>> print el.text
>>> ''

    Donc, si vous souhaitez utiliser le nouvel objet que vous devriez faire à nouveau:

    >>> MyModel.objects.create(pk=1, text='')
>>> el = MyModel.objects.get(pk=1)
>>> queryset.filter(pk=1).update(text='Updated')
>>> el = MyModel.objects.get(pk=1) # Do it again
>>> print el.text
>>> 'Updated'
    InformationsquelleAutor ruhanbidart
  7. 4

    Vous pouvez aussi vérifier les raw argument en post_save et ensuite appeler save_baseau lieu de save.

    • En fait, save_base envoie le signal; pas save.
    • Bien sûr, mais vous ne pouvez pas envoyer raw=True de la save méthode.
    • Maintenant, je suis à votre point de vue. En gardant cela à l'esprit, c'est vraiment du chemin à faire pour moi.
    InformationsquelleAutor dragoon
  8. 0

    Vérifier cela...

    Chaque signal a ses propres avantages que vous pouvez lire à ce sujet dans les docs ici, mais je voulais partager un couple de choses à garder à l'esprit avec la pre_save et post_save signaux.

    • Les deux sont appelés à chaque fois .save() sur un modèle est appelé. En d'autres termes, si vous enregistrez le modèle de l'instance, les signaux sont envoyés.

    • l'exécution de la méthode save() sur l'instance au sein d'un post_save peut souvent créer une boucle sans fin, et donc provoquer un max profondeur de récursion dépassé erreur --- uniquement si vous n'utilisez pas .save() correctement.

    • pre_save est idéal pour la modification des données d'instance parce que vous n'avez pas à appeler save() jamais ce qui élimine la possibilité de ci-dessus. La raison pour laquelle vous n'avez pas à appeler save() c'est parce que un pre_save signal signifie littéralement droite avant d'être enregistré.

    • Signaux peuvent appeler d'autres signaux et ou exécuter retard de tâches (Céleri), qui peut être énorme pour la facilité d'utilisation.

    Source: https://www.codingforentrepreneurs.com/blog/post-save-vs-pre-save-vs-override-save-method/

    Ce qui concerne l'!!

    InformationsquelleAutor Jesús Díaz