Detecting Updates on Arbitrary Objects

[Paul Johnston]

Hi,

I would like to be able to install a code hook to detect updates on
arbitrary objects. To give some background, I'm writing a web widget
library, that uses request-local storage. If there's a mutable object
on a widget (a dict is common), I'd like any attempts to update the
dict to cause the dict to be cloned into request-local storage and the
update applied.

Now, I did have this working quite nicely for dict and list instances,
by subclassing dict and list, and overriding the write methods (or
most of them - __setitem__, __delitem__, append, etc.) When the dict/
list is added to the widget, it's replaced with a clone, using the
DictProxy/ListProxy subclass. (I realise Proxy may have been slightly
inaccurate as a name) However, sometimes a user needs to use a list-
like object that isn't a list, and this approach breaks down.

So, I think I need to do a real object proxy - a class that defers
almost all attributes to an inner instance that it stores, but
overrides a few. The following is my initial attempt, which almost
works, but I think there must be a better way. In particular, needing
to explicitly override __iter__ and __eq__ spells trouble - what about
__ne__, __gt__, etc. Also, is there a way to catch just any change,
rather than trying to know all the change methods. A way to do this
for arbitrary objects (not just dicts and lists) would be good too.

Any hints, tips, or pointers to docs online?

Thanks,

Paul


class GenericProxy(object):
def __init__(self, obj):
self._obj = obj
def __getattr__(self, a):
return getattr(self._obj, a)

def __iter__(self):
return self._obj.__iter__()
def __eq__(self, x):
return self._obj.__eq__(x)

__setitem__ = _catch_modify('__setitem__')
__delitem__ = _catch_modify('__delitem__')
append = _catch_modify('append')
insert = _catch_modify('insert')