Python | class method decorator before instantiation

Question

Foreword: this question is probably simpler than the title may suggest

I am trying to implement a simple event handler system, using decorators to 'subscribe' various methods and functions to an event.

1. Simple approach to event handlers

A simple approach would be to create a class for adding and running the event:

# class for adding and running functions, aka an event handler
class Runner:
    def __init__(self):
        self.functions = []
    def add(self, function):
        self.functions.append(function)
    def run(self):
        for function in self.functions:
            function()

runner = Runner()

and then adding various functions or methods:

# random example function
def myFunction():
    print('myFunction')

# random example class
class MyClass:
    def myMethod(self):
        print('myMethod')

# getting instance of class & method
myObject = MyClass()
myObjectMethod = myObject.myMethod

runner.add(myFunction)
runner.add(myObjectMethod)
runner.run()

Which leads to:

> py main.py
myFunction
myMethod

Nice! It works as expected

2. Decorator approach

So this is okay, but I've recently learned about decorators and thought I could tidy up the syntax by replacing the somewhat ugly runner.add() method.

First I change the Runner.add() method to work as a decorator:

class Runner:
    def __init__(self):
        self.functions = []
    def add(self, function):
        self.functions.append(function)
        return function # <-- returns function
    def run(self):
        for function in self.functions:
            function()

runner = Runner()

Then I remove the runner.add() calls and insert the decorator:

@runner.add
def myFunction():
    print('myFunction')

class MyClass:
    @runner.add
    def myMethod(self):
        print('myMethod')

# myObject = MyClass()
# myObjectMethod = myObject.myMethod

runner.run()

Which obviously leads to:

> py main.py
myFunction
Traceback (most recent call last):
...
TypeError: myMethod() missing 1 required positional argument: 'self'

Clearly the problem here is that I'm adding the 'static' (or is it 'unbound'?) myMethod to the event, which isn't associated with an instance and therefore doesn't have any instance of self.

Answers such as this one refer to implementing decorators to wrap methods as they're called, however my reason for using decorators is the access you get upon initial code execution.

A thought is that something would have to run in the MyClass.__init__() constructor, since only then has an instance been created and you have access to self, but how then how would you run a decorator only on instantiation? Let alone to achieve the result we're after here.

The question

What options do I have for implementing behaviour shown in example 1, but with syntax as close as possible to example 2 (or any other 'clean looking' variant perhaps) due to runner.add() being kinda verbose, ugly, and certainly not as streamlined as decorators.

Cheers!

should every instance of `MyClass` that ever gets created be added to the `Runner`? how do they get removed? what's wrong with using functions? — Sam Mason, Aug 13 '20 at 13:57
@SamMason Yes, every instance (and subclass even) should have its `myMethod` added to `Runner`. And as mentioned I wanted a cleaner syntax for event subscription - the inline syntax with decorators seems much more preferable. — dwb, Aug 13 '20 at 14:16
why not just put `runner.add(self.myMethod)` in `__init__`? it makes it more obvious to readers of the code what's going on, and that this will affect every instance. the only way I can think of making it work would be messing around with metaclasses and involving the `__new__` method. hopefully somebody else will have an easier idea! — Sam Mason, Aug 13 '20 at 15:29

dwb · Accepted Answer · 2020-08-17T09:12:25.987

Instead of treating functions and methods the same, you handle them slightly differently:

Function:

[A] Add function as normal to list

Method:

An unbound method when the decorator is called, so doesn't have an associated instance or value for self yet
[B] We 'tag' the method while its unbound (before an instance has been created) by setting its _tagged attribute
[C] Once an instance has been created (and the self variable has been filled), inside __init__() we search through and add all tagged methods
We can add the methods afterwards since once they're bound to an instance the self argument is filled (meaning it technically has no parameters, akin to functools.partial())

import inspect

class Runner:
    def __init__(self):
        self.functions = []

    def add(self, function):
        if len(inspect.signature(function).parameters) == 0:
            # [A] adds if has no parameters
            self.functions.append(function)
        else:
            # [B] tags if has 1 parameter (unbound methods have "self" arg)
            function._tagged = True
        return function

    # [C] search through object and add all tagged methods
    def add_all_tagged_methods(self, object):
        for method_name in dir(object):
            method = getattr(object, method_name)
            if hasattr(method, '_tagged'):
                self.functions.append(method)

    def run(self):
        for function in self.functions:
            function()

runner = Runner()

Then use the same initial code as below

@runner.add
def myFunction():
    print('myFunction')

class MyClass:
    def __init__(self):
        runner.add_all_tagged_methods(self)

    @runner.add
    def myMethod(self):
        print('myMethod')

myObject = MyClass()
myObjectMethod = myObject.myMethod

runner.run()

Python | class method decorator before instantiation

1. Simple approach to event handlers

2. Decorator approach

The question

1 Answers1

Linked