Looking for a solution to detect value change in class attribute with a list and append

Question

Looking for a solution to detect value change when I do : class_instance.list.append(value). I wrote a little example to illustrate my problem.

class Foo(object):

    def __setattr__(self, key, value):
        print('set -> ', key, value)
        self.__dict__[key] = value

if __name__ == '__main__':
    f = Foo()
    #set/change detected
    f.bar = ['foo']

    # change not detected
    f.bar.append('bar')

    #change detected
    f.bar = ['foo', 'bar']

Thank you for your help.

You can't. You would have to use a custom datatype that notifies its "parent", instead of using a regular list. — BrenBarn, Apr 05 '14 at 08:08
Alternatively, you could have your own method, and do `f.append_to("bar", "foo")` — jonrsharpe, Apr 05 '14 at 08:50
@BrenBarn you can override __setitem__ method and wrap List type value with TrackedList class — Stéphane Klein, Apr 05 '14 at 09:18
It would help to know how general you want this to be. Do you want to detect a change in any object attached to your class as an attribute, or just lists? (what if it was a dictionary or an instance of a custom class attached to `f.bar` which was modified in a similar way to your example?) Do you just want to detect changes to the object at `f.bar`, a predefined list of attribute names, or an arbitrary number of attributes of which the names are unknown? — three_pineapples, Apr 05 '14 at 12:09
@harobed: Yes, that's what I mean by "use a custom datatype instead of a regular list". — BrenBarn, Apr 05 '14 at 17:37
@three_pineapples I want particulary detect changes in a list or a dict. I think with an observer class, I can do the trick. — k3z, Apr 05 '14 at 19:00

score 4 · Accepted Answer · edited May 23 '17 at 11:53

With help of @harobed, I found this solution http://code.activestate.com/recipes/306864-list-and-dictionary-observer/, credits goes to Bernhard Mulder for the observer class.

Here is a working sample of what I want to achieve

class Foo(object):

    def __init__(self):
        self._dirty = False

    def __setattr__(self, key, value):
        if key != '_dirty':
            if isinstance(value, list):
                self.__dict__[key] = list_observer(value, self.observer(self))
            else:
                self.__dict__[key] = value
            self._make_dirty()

    def _make_dirty(self):
        self._dirty = True
        print('is dirty')

    def _not_dirty(self):
        self._dirty = False
        print('is no more dirty')

    class observer(object):
        """
        If a call to a method is made, this class prints the name of the method
        and all arguments.
        """

        def __init__(self, instance):
            self.instance = instance

        def p(self, *args):
            print self.attr, args
            self.instance._make_dirty()

        def __getattr__(self, attr):
            self.attr = attr
            return self.p


class list_observer(list):
    """
    Send all changes to an observer.
    """

    def __init__(self, value, observer):
        list.__init__(self, value)
        self.set_observer(observer)

    def set_observer(self, observer):
        """
        All changes to this list will trigger calls to observer methods.
        """
        self.observer = observer

    def __setitem__(self, key, value):
        """
        Intercept the l[key]=value operations.
        Also covers slice assignment.
        """
        try:
            oldvalue = self.__getitem__(key)
        except KeyError:
            list.__setitem__(self, key, value)
            self.observer.list_create(self, key)
        else:
            list.__setitem__(self, key, value)
            self.observer.list_set(self, key, oldvalue)

    def __delitem__(self, key):
        oldvalue = list.__getitem__(self, key)
        list.__delitem__(self, key)
        self.observer.list_del(self, key, oldvalue)

    def __setslice__(self, i, j, sequence):
        oldvalue = list.__getslice__(self, i, j)
        self.observer.list_setslice(self, i, j, sequence, oldvalue)
        list.__setslice__(self, i, j, sequence)

    def __delslice__(self, i, j):
        oldvalue = list.__getitem__(self, slice(i, j))
        list.__delslice__(self, i, j)
        self.observer.list_delslice(self, i, oldvalue)

    def append(self, value):
        list.append(self, value)
        self.observer.list_append(self)

    def pop(self):
        oldvalue = list.pop(self)
        self.observer.list_pop(self, oldvalue)

    def extend(self, newvalue):
        list.extend(self, newvalue)
        self.observer.list_extend(self, newvalue)

    def insert(self, i, element):
        list.insert(self, i, element)
        self.observer.list_insert(self, i, element)

    def remove(self, element):
        index = list.index(self, element)
        list.remove(self, element)
        self.observer.list_remove(self, index, element)

    def reverse(self):
        list.reverse(self)
        self.observer.list_reverse(self)

    def sort(self, cmpfunc=None):
        oldlist = self[:]
        list.sort(self, cmpfunc)
        self.observer.list_sort(self, oldlist)


if __name__ == '__main__':
    f = Foo()

    #change detected, f is dirty
    f.bar = ['foo']
    f._not_dirty()

    #change detected, f is dirty again
    f.bar.append('bar')

EDIT Is better to Rely on isinstance(a, list) to detect type according to this post -> Differences between isinstance() and type() in python

Looking for a solution to detect value change in class attribute with a list and append

1 Answers1

Linked