Question

I need to refactor existing code by collapsing a method that’s copy-and-pasted between various classed that inherit from one another into a single method.
So I produced the following code:

class A(object):
    def rec(self):
        return 1

class B(A):
    def rec(self):
        return self.rec_gen(B)

    def rec_gen(self, rec_class):
        return super(rec_class, self).rec() + 1

class C(B):
    def rec(self):
        return self.rec_gen(C)

if __name__=='__main__':
    b = B(); c = C()
    print c.rec()
    print b.rec()

And the output:

3
2

What still bothers me is that in the ‘rec’ method I need to tell ‘rec_gen’ the context of the class in which it’s running. Is there a way for ‘rec_gen’ to figure it out by itself in runtime?

Answer 1

This capability has been added to Python 3 – see PEP 3135. In a nutshell:

class B(A):
    def rec(self):
        return super().rec() + 1

I think you’ve created the convoluted rec()/rec_gen() setup because you couldn’t automatically find the class, but in case you want that anyway the following should work:

class A(object):
    def rec(self):
        return 1

class B(A):
    def rec(self):
        # __class__ is a cell that is only created if super() is in the method
        super()
        return self.rec_gen(__class__)

    def rec_gen(self, rec_class):
        return super(rec_class, self).rec() + 1

class C(B):
    def rec(self):
        # __class__ is a cell that is only created if super() is in the method
        super()
        return self.rec_gen(__class__)

The simplest solution in Python 2 is to use a private member to hold the super object:

class B(A):
    def __init__(self):
        self.__super = super(B)

    def rec(self):
        return self.__super.rec() + 1

But that still suffers from the need to specify the actual class in one place, and if you happen to have two identically-named classes in the class hierarchy (e.g. from different modules) this method will break.

There were a couple of us who made recipes for automatic resolution for Python 2 prior to the existence of PEP 3135 – my method is at self.super on ActiveState. Basically, it allows the following:

class B(A, autosuper):
    def rec(self):
        return self.super().rec() + 1

or in the case that you’re calling a parent method with the same name (the most common case):

class B(A, autosuper):
    def rec(self):
        return self.super() + 1

Caveats to this method:

1. It’s quite slow. I have a version sitting around somewhere that does bytecode manipulation to improve the speed a lot.

2. It’s not consistent with PEP 3135 (although it was a proposal for the Python 3 super at one stage).

3. It’s quite complex.

4. It’s a mix-in base class.

I don’t know if the above would enable you to meet your requirements. With a small change to the recipe though you could find out what class you’re in and pass that to rec_gen() – basically extract the class-finding code out of _getSuper() into its own method.