Question

I want to implement function which takes as argument any object and trackes changes of value for specific attribute. Than saves old value of attribute in old_name attribute.

For example:

class MyObject(object):
     attr_one = None
     attr_two = 1

Lets name my magic function magic_function()

Sot than i can do like this:

obj = MyObject()
obj = magic_function(obj)
obj.attr_one = 'new value'
obj.attr_two = 2

and it saves old values so i can get like this

print obj.old_attr_one
None
print obj.attr_one 'new value'

and

print obj.old_attr_two
1
print obj.attr_two
2

Something like this.. I wonder how can i do this by not touching the class of instance?

Answer 1

This is a start:

class MagicWrapper(object):
    def __init__(self, wrapped):
        self._wrapped = wrapped

    def __getattr__(self, attr):
        return getattr(self._wrapped, attr)

    def __setattr__(self, attr, val):
        if attr == '_wrapped':
            super(MagicWrapper, self).__setattr__('_wrapped', val)
        else:
            setattr(self._wrapped, 'old_' + attr, getattr(self._wrapped, attr))
            setattr(self._wrapped, attr, val)


class MyObject(object):
    def __init__(self):
        self.attr_one = None
        self.attr_two = 1

obj = MyObject()
obj = MagicWrapper(obj)
obj.attr_one = 'new value'
obj.attr_two = 2

print obj.old_attr_one
print obj.attr_one
print obj.old_attr_two
print obj.attr_two

This isn’t bullet-proof when you’re trying to wrap weird objects (very little in Python is), but it should work for “normal” classes. You could write a lot more code to get a little bit closer to fully cloning the behaviour of the wrapped object, but it’s probably impossible to do perfectly. The main thing to be aware of here is that many special methods will not be redirected to the wrapped object.

If you want to do this without wrapping obj in some way, it’s going to get messy. Here’s an option:

def add_old_setattr_to_class(cls):
    def __setattr__(self, attr, val):
        super_setattr = super(self.__class__, self).__setattr__
        if attr.startswith('old_'):
            super_setattr(attr, val)
        else:
            super_setattr('old_' + attr, getattr(self, attr))
            super_setattr(attr, val)
    cls.__setattr__ = __setattr__


class MyObject(object):
    def __init__(self):
        self.attr_one = None
        self.attr_two = 1

obj = MyObject()
add_old_setattr_to_class(obj.__class__)
obj.attr_one = 'new value'
obj.attr_two = 2

print obj.old_attr_one
print obj.attr_one
print obj.old_attr_two
print obj.attr_two

Note that this is extremely invasive if you’re using it on externally provided objects. It globally modifies the class of the object you’re applying the magic to, not just that one instance. This is because like several other special methods, __setattr__ is not looked up in the instance’s attribute dictionary; the lookup skips straight to the class, so there’s no way to just override __setattr__ on the instance. I would characterise this sort of code as a bizarre hack if I encountered it in the wild (it’s “nifty cleverness” if I write it myself, of course 😉 ).

This version may or may not play nicely with objects that already play tricks with __setattr__ and __getattr__/__getattribute__. If you end up modifying the same class several times, I think this still works, but you end up with an ever-increasing number of wrapped __setattr__ definitions. You should probably try to avoid that; maybe by setting a “secret flag” on the class and checking for it in add_old_setattr_to_class before modifying cls. You should probably also use a more-unlikely prefix than just old_, since you’re essentially trying to create a whole separate namespace.