I have defined a class that defines a decorator as a method of that class. The decorator itself creates a callable instance of a second class that replaces the decorated method. Since the decorated method is now actually a class, I can call methods on it. In my (fictional, minimal) example I want to register callbacks with a custom maximum number of callbacks per method.
class CallbackAcceptor:
def __init__(self, max_num_callbacks, func):
self._func = func
self._max_num_callbacks = max_num_callbacks
self._callbacks = []
def __call__(self, *args, **kwargs):
# This ends up being called when the decorated method is called
for callback in self._callbacks:
print(f"Calling {callback.__name__}({args}, {kwargs})")
callback(*args, **kwargs)
return self._func(*args, **kwargs) # this line is the problem, self is not bound
def register_callback(self, func):
# Here I can register another callback for the decorated function
if len(self._callbacks) < self._max_num_callbacks:
self._callbacks.append(func)
else:
raise RuntimeError(f"Can not register any more callbacks for {self._func.__name__}")
return func
class MethodsWithCallbacksRegistry:
def __init__(self):
self.registry = {} # Keep track of everything that accepts callbacks
def accept_callbacks(self, max_num_callbacks: int = 1):
def _make_accept_callbacks(func):
# Convert func to an CallbackAcceptor instance so we can register callbacks on it
if func.__name__ not in self.registry:
self.registry[func.__name__] = CallbackAcceptor(max_num_callbacks=max_num_callbacks, func=func)
return self.registry[func.__name__]
return _make_accept_callbacks
Everything works as expected for functions, but when I decorate a class methods it breaks, because the class instance is not bound to the decorated method:
registry = MethodsWithCallbacksRegistry()
@registry.accept_callbacks(max_num_callbacks=1)
def bar(i):
return i * 10
@bar.register_callback
def bar_callback(*args, **kwargs):
print("Bar Callback")
print(bar(i=10)) # Works fine, prints "Bar Callback" and then 100
Now if I define a method to accept callbacks:
class Test:
@registry.accept_callbacks(max_num_callbacks=1)
def foo(self, i):
return i * 2
@Test.foo.register_callback
def foo_callback(*args, **kwargs):
print("Foo Callback")
It works if I pass self explicitly, but not if I just assume that the instance is bound:
t = Test()
# Note that I pass the instance of t explicitly as self
Test.foo(t, i=5) # Works, prints "Foo Callback" and then 10
t.foo(t, i=5) # Works, prints "Foo Callback" and then 10
t.foo(i=5) # Crashes, because self is not passed to foo
This is the traceback:
Traceback (most recent call last):
File "/home/veith/.PyCharmCE2019.3/config/scratches/scratch_4.py", line 62, in <module>
t.foo(i=5)
File "/home/veith/.PyCharmCE2019.3/config/scratches/scratch_4.py", line 13, in __call__
return self._func(*args, **kwargs) # this line is the problem, self is not bound
TypeError: foo() missing 1 required positional argument: 'self'
I always though that t.foo(i=5) is basically syntactic sugar for Test.foo(t, i=5) via descriptors, but it seems I am wrong. So here are my questions:
Thank you!
PS: I am using python 3.8
If you make CallbackAcceptor a descriptor it works as follows:
class CallbackAcceptor:
def __init__(self, max_num_callbacks, func):
self._func = func
self._max_num_callbacks = max_num_callbacks
self._callbacks = []
def __call__(self, *args, **kwargs):
# This ends up being called when the decorated method is called
for callback in self._callbacks:
print(f"Calling {callback.__name__}({args}, {kwargs})")
callback(*args, **kwargs)
return self._func(*args, **kwargs)
def register_callback(self, func):
# Here I can register another callback for the decorated function
if len(self._callbacks) < self._max_num_callbacks:
self._callbacks.append(func)
else:
raise RuntimeError(f"Can not register any more callbacks for {self._func.__name__}")
return func
# Implementing __get__ makes this a descriptor
def __get__(self, obj, objtype=None):
if obj is not None:
# the call is made on an instance, we can pass obj as the self of the function that will be called
return functools.partial(self.__call__, obj)
# Called on a class or a raw function, just return self so we can register more callbacks
return self
Calling now works as expected:
print(bar(i=10))
# Bar Callback
# 100
t = Test()
t.foo(i=5)
# Foo Callback
# 10
t.foo(t, i=5)
# TypeError: foo() got multiple values for argument 'i'