Which Python dunder/magic methods do you need to implement to correctly proxy an object?

__abs__ __add__ __aenter__ __aexit__ __aiter__ __and__ __anext__ __await__ __bool__ __bytes__ __call__ __class__ __cmp__ __complex__ __contains__ __delattr__ __delete__ __delitem__ __delslice__ __dir__ __div__ __divmod__ __enter__ __eq__ __exit__ __float__ __floordiv__ __format__ __fspath__ __ge__ __get__ __getattribute__ __getitem__ __getnewargs__ __getslice__ __gt__ __hash__ __iadd__ __iand__ __import__ __imul__ __index__ __init__ __init_subclass__ __instancecheck__ __int__ __invert__ __ior__ __isub__ __iter__ __ixor__ __le__ __len__ __lshift__ __lt__ __mod__ __mul__ __ne__ __neg__ __new__ __next__ __nonzero__ __or__ __pos__ __pow__ __prepare__ __radd__ __rand__ __rdiv__ __rdivmod__ __reduce__ __reduce_ex__ __repr__ __reversed__ __rfloordiv__ __rlshift__ __rmod__ __rmul__ __ror__ __round__ __rpow__ __rrshift__ __rshift__ __rsub__ __rtruediv__ __rxor__ __set__ __setattr__ __setitem__ __setslice__ __sizeof__ __str__ __sub__ __subclasscheck__ __subclasses__ __truediv__ __xor__

To proxy an object, you only need to implement the dunder methods that the object has, so in the simplest world, you wouldn't need to do anything special to proxy them that you're not already doing to proxy the object's other attributes.

However, the wrinkle is that dunder methods are looked up on the class, not on the object, so while for example Foo().bar will look up bar on the instance before falling back to the class if the instance has no bar attribute, Foo() + 5 will look up __add__ on the class Foo, completely ignoring the instance. That is, if the instance does have an instance attribute named __add__, then Foo() + 5 still won't use that instance attribute.

So to proxy those dunder methods, they need to be proxied at the class level, not the instance level.

from functools import wraps

def proxy_function(name, f):
    @wraps(f)
    def proxied_f(*args, **kwargs):
        print('Proxying function:', name)
        return f(*args, **kwargs)
    return proxied_f

def proxy_object(obj):
    class Proxy:
        def __getattr__(self, name):
            print('Proxying getattr:', name)
            return getattr(obj, name)
        def __hasattr__(self, name):
            print('Proxying hasattr:', name)
            return hasattr(obj, name)
        def __setattr__(self, name, value):
            print('Proxying setattr:', name, '=', repr(value))
            setattr(obj, name, value)
        def __delattr__(self, name):
            print('Proxying delattr:', name)
            delattr(obj, name)
    
    for name, f in obj.__class__.__dict__.items():
        # don't try to overwrite __class__, __getattr__, etc.
        if callable(f) and name not in Proxy.__dict__:
            f = proxy_function(name, f)
            setattr(Proxy, name, f)
    
    return Proxy()

Usage:

>>> class Foo:
...     def __add__(self, other):
...         return 'Adding with ' + repr(other)
... 
>>> foo = Foo()
>>> proxy_foo = proxy_object(foo)
>>> foo + 5
'Adding with 5'
>>> proxy_foo + 5
Proxying function: __add__
'Adding with 5'

Recommended topics

Hot tags