Пример #1
0
 def watch(self, call_on_created=None):
     self._call_on_created = (self._call_on_created if
                              call_on_created is None else call_on_created)
     # initialize investigator
     self._investigator = Investigator(self.model, include=[self.attr])
     # register the receivers
     register_reciever(self.model, pre_save, self._pre_save_receiver)
     register_reciever(self.model, post_save, self._post_save_receiver)
Пример #2
0
class ValueWatcher(WatcherBase):
    """
    Watcher field for watching non relational field such as CharField.
    """
    def __init__(self, model, attr, callback, call_on_created=True):
        super(ValueWatcher, self).__init__(model, attr, callback)
        self._call_on_created = call_on_created

    def watch(self, call_on_created=None):
        self._call_on_created = (self._call_on_created
                                 if call_on_created is None
                                 else call_on_created)
        # initialize investigator
        self._investigator = Investigator(self.model, include=[self.attr])
        # register the receivers
        register_reciever(self.model, pre_save,
                          self._pre_save_receiver)
        register_reciever(self.model, post_save,
                          self._post_save_receiver)

    def unwatch(self):
        unregister_reciever(self.model, pre_save,
                            self._pre_save_receiver)
        unregister_reciever(self.model, post_save,
                            self._post_save_receiver)

    def _pre_save_receiver(self, sender, instance, **kwargs):
        if kwargs.get('row', False):
            # should not call any callback while it is called via fixtures or
            # so on
            return
        self._investigator.prepare(instance)

    def _post_save_receiver(self, sender, instance, created, **kwargs):
        if kwargs.get('row', False):
            # should not call any callback while it is called via fixtures or
            # so on
            return
        if self._call_on_created and created:
            self.call(instance)
        # if investigator yield any field_name, call the callback
        if any(self._investigator.investigate(instance)):
            self.call(instance)
Пример #3
0
 def watch(self, call_on_created=None, include=None, exclude=None):
     self._call_on_created = (self._call_on_created if
                              call_on_created is None else call_on_created)
     include = include or self.include
     exclude = exclude or self.exclude
     self._investigator = Investigator(self.related_model,
                                       include=include,
                                       exclude=exclude)
     # register the receivers
     register_reciever(self.model,
                       pre_save,
                       self._pre_save_receiver,
                       sender=self.related_model)
     register_reciever(self.model,
                       post_save,
                       self._post_save_receiver,
                       sender=self.related_model)
     register_reciever(self.model, post_save,
                       self._post_save_receiver_for_creation)
Пример #4
0
 def watch(self, call_on_created=None):
     self._call_on_created = (self._call_on_created
                              if call_on_created is None
                              else call_on_created)
     # initialize investigator
     self._investigator = Investigator(self.model, include=[self.attr])
     # register the receivers
     register_reciever(self.model, pre_save,
                       self._pre_save_receiver)
     register_reciever(self.model, post_save,
                       self._post_save_receiver)
Пример #5
0
class ValueWatcher(WatcherBase):
    """
    Watcher field for watching non relational field such as CharField.
    """
    def __init__(self, model, attr, callback, call_on_created=True):
        super(ValueWatcher, self).__init__(model, attr, callback)
        self._call_on_created = call_on_created

    def watch(self, call_on_created=None):
        self._call_on_created = (self._call_on_created if
                                 call_on_created is None else call_on_created)
        # initialize investigator
        self._investigator = Investigator(self.model, include=[self.attr])
        # register the receivers
        register_reciever(self.model, pre_save, self._pre_save_receiver)
        register_reciever(self.model, post_save, self._post_save_receiver)

    def unwatch(self):
        unregister_reciever(self.model, pre_save, self._pre_save_receiver)
        unregister_reciever(self.model, post_save, self._post_save_receiver)

    def _pre_save_receiver(self, sender, instance, **kwargs):
        if kwargs.get('row', False):
            # should not call any callback while it is called via fixtures or
            # so on
            return
        self._investigator.prepare(instance)

    def _post_save_receiver(self, sender, instance, created, **kwargs):
        if kwargs.get('row', False):
            # should not call any callback while it is called via fixtures or
            # so on
            return
        if self._call_on_created and created:
            self.call(instance)
        # if investigator yield any field_name, call the callback
        if any(self._investigator.investigate(instance)):
            self.call(instance)
Пример #6
0
 def watch(self, call_on_created=None, include=None, exclude=None):
     self._call_on_created = (self._call_on_created
                              if call_on_created is None
                              else call_on_created)
     include = include or self.include
     exclude = exclude or self.exclude
     self._investigator = Investigator(self.related_model,
                                       include=include,
                                       exclude=exclude)
     # register the receivers
     register_reciever(self.model, pre_save,
                       self._pre_save_receiver,
                       sender=self.related_model)
     register_reciever(self.model, post_save,
                       self._post_save_receiver,
                       sender=self.related_model)
     register_reciever(self.model, post_save,
                       self._post_save_receiver_for_creation)
Пример #7
0
class RelatedWatcherBase(WatcherBase):
    """
    A base watcher field for relational field such as ForeignKey, ManyToMany
    """
    def __init__(self, model, attr, callback,
                 call_on_created=True,
                 include=None, exclude=None):
        """
        Construct watcher field

        Args:
            model (model): A target model class
            attr (str): A name of attribute
            callback (fn): A callback function
            call_on_created (bool): Call callback when the new instance is
                created
            include (None, list, tuple): A related object field name list
                which will be investigated to determine the modification
            exclude (None, list, tuple): A related object field name list
                which won't be investigated to determine the modification
        """
        super(RelatedWatcherBase, self).__init__(model, attr, callback)
        self.include = include
        self.exclude = exclude
        self._call_on_created = call_on_created

    @property
    @lru_cache(settings.OBSERVER_LRU_CACHE_SIZE)
    def is_reversed(self):
        return self.get_field().model != self._model

    @property
    @lru_cache(settings.OBSERVER_LRU_CACHE_SIZE)
    def related_model(self):
        field = self.get_field()
        if self.is_reversed:
            return field.model
        return field.related.parent_model

    @property
    @lru_cache(settings.OBSERVER_LRU_CACHE_SIZE)
    def related_attr(self):
        field = self.get_field()
        if self.is_reversed:
            return field.name
        return field.related.get_accessor_name()

    def watch(self, call_on_created=None, include=None, exclude=None):
        self._call_on_created = (self._call_on_created
                                 if call_on_created is None
                                 else call_on_created)
        include = include or self.include
        exclude = exclude or self.exclude
        self._investigator = Investigator(self.related_model,
                                          include=include,
                                          exclude=exclude)
        # register the receivers
        register_reciever(self.model, pre_save,
                          self._pre_save_receiver,
                          sender=self.related_model)
        register_reciever(self.model, post_save,
                          self._post_save_receiver,
                          sender=self.related_model)
        register_reciever(self.model, post_save,
                          self._post_save_receiver_for_creation)

    def unwatch(self):
        # unregister the receivers
        unregister_reciever(self.model, pre_save,
                            self._pre_save_receiver)
        unregister_reciever(self.model, post_save,
                            self._post_save_receiver)
        unregister_reciever(self.model, post_save,
                            self._post_save_receiver_for_creation)

    def get_value(self, instance):
        try:
            return getattr(instance, self.related_attr, None)
        except ObjectDoesNotExist:
            return None

    def get_values(self, instance):
        value = self.get_value(instance)
        if value is None:
            return set()
        if hasattr(value, 'iterator'):
            value = value.iterator()
        elif not hasattr(value, '__iter__'):
            value = tuple([value])
        return set(value)

    def _pre_save_receiver(self, sender, instance, **kwargs):
        if kwargs.get('row', False):
            # should not call any callback while it is called via fixtures or
            # so on
            return
        self._investigator.prepare(instance)

    def _post_save_receiver(self, sender, instance, **kwargs):
        if kwargs.get('row', False):
            # should not call any callback while it is called via fixtures or
            # so on
            return
        # get a reverse related objects from the instance
        instance_cached = self._investigator.get_cached(instance.pk)
        values_cached = self.get_values(instance_cached)
        values_latest = self.get_values(instance)
        object_set = values_cached | values_latest
        if any(self._investigator.investigate(instance)):
            for obj in object_set:
                self.call(obj)

    def _post_save_receiver_for_creation(self, sender, instance,
                                         created, **kwargs):
        if kwargs.get('row', False):
            # should not call any callback while it is called via fixtures or
            # so on
            return
        if self._call_on_created and created:
            self.call(instance)
Пример #8
0
class RelatedWatcherBase(WatcherBase):
    """
    A base watcher field for relational field such as ForeignKey, ManyToMany
    """
    def __init__(self,
                 model,
                 attr,
                 callback,
                 call_on_created=True,
                 include=None,
                 exclude=None):
        """
        Construct watcher field

        Args:
            model (model): A target model class
            attr (str): A name of attribute
            callback (fn): A callback function
            call_on_created (bool): Call callback when the new instance is
                created
            include (None, list, tuple): A related object field name list
                which will be investigated to determine the modification
            exclude (None, list, tuple): A related object field name list
                which won't be investigated to determine the modification
        """
        super(RelatedWatcherBase, self).__init__(model, attr, callback)
        self.include = include
        self.exclude = exclude
        self._call_on_created = call_on_created

    @property
    @lru_cache(settings.OBSERVER_LRU_CACHE_SIZE)
    def is_reversed(self):
        return self.get_field().model != self._model

    @property
    @lru_cache(settings.OBSERVER_LRU_CACHE_SIZE)
    def related_model(self):
        field = self.get_field()
        if self.is_reversed:
            return field.model
        return field.related.parent_model

    @property
    @lru_cache(settings.OBSERVER_LRU_CACHE_SIZE)
    def related_attr(self):
        field = self.get_field()
        if self.is_reversed:
            return field.name
        return field.related.get_accessor_name()

    def watch(self, call_on_created=None, include=None, exclude=None):
        self._call_on_created = (self._call_on_created if
                                 call_on_created is None else call_on_created)
        include = include or self.include
        exclude = exclude or self.exclude
        self._investigator = Investigator(self.related_model,
                                          include=include,
                                          exclude=exclude)
        # register the receivers
        register_reciever(self.model,
                          pre_save,
                          self._pre_save_receiver,
                          sender=self.related_model)
        register_reciever(self.model,
                          post_save,
                          self._post_save_receiver,
                          sender=self.related_model)
        register_reciever(self.model, post_save,
                          self._post_save_receiver_for_creation)

    def unwatch(self):
        # unregister the receivers
        unregister_reciever(self.model, pre_save, self._pre_save_receiver)
        unregister_reciever(self.model, post_save, self._post_save_receiver)
        unregister_reciever(self.model, post_save,
                            self._post_save_receiver_for_creation)

    def get_value(self, instance):
        try:
            return getattr(instance, self.related_attr, None)
        except ObjectDoesNotExist:
            return None

    def get_values(self, instance):
        value = self.get_value(instance)
        if value is None:
            return set()
        if hasattr(value, 'iterator'):
            value = value.iterator()
        elif not hasattr(value, '__iter__'):
            value = tuple([value])
        return set(value)

    def _pre_save_receiver(self, sender, instance, **kwargs):
        if kwargs.get('row', False):
            # should not call any callback while it is called via fixtures or
            # so on
            return
        self._investigator.prepare(instance)

    def _post_save_receiver(self, sender, instance, **kwargs):
        if kwargs.get('row', False):
            # should not call any callback while it is called via fixtures or
            # so on
            return
        # get a reverse related objects from the instance
        instance_cached = self._investigator.get_cached(instance.pk)
        values_cached = self.get_values(instance_cached)
        values_latest = self.get_values(instance)
        object_set = values_cached | values_latest
        if any(self._investigator.investigate(instance)):
            for obj in object_set:
                self.call(obj)

    def _post_save_receiver_for_creation(self, sender, instance, created,
                                         **kwargs):
        if kwargs.get('row', False):
            # should not call any callback while it is called via fixtures or
            # so on
            return
        if self._call_on_created and created:
            self.call(instance)