Question

I’ve got the following problem:

I need to write a decorator that would be able to detect a situation where it is used around a method and around a regular function.

So let’s consider the following code:

def somedecorator(fn):
    print "decorating function:", fn
    print "function class:", fn.__class__
    return fn

@somedecorator
def regular_func():
    print "I'm a regular function"

class SomeClass(object):

    @somedecorator
    def class_method(self):
        print "I'm a class method"

The output reads:

decorating function: <function regular_func at 0x181d398>
function class: <type 'function'>
decorating function: <function class_method at 0x181d410>
function class: <type 'function'>

However writing:

print regular_func
print SomeClass.class_method
print SomeClass().class_method

Produces output:

<function regular_func at 0x181d398>
<unbound method SomeClass.class_method>
<bound method SomeClass.class_method of <__main__.SomeClass object at 0x16d9e50>>

So as it turns out (not so surprisingly) that decorators are applied to functions before they are turned into methods.

Question: What would you suggest to distinguish the two applications from the decorator point of view?

EDIT
For the curious ones – I need the described distinction because of pickling. I don’t really want to go into details on this one.

Answer 1

May be looking at the stack?

def somedecorator(fn):
    import traceback
    print "decorating function:", fn
    print "function class:", fn.__class__
    print traceback.extract_stack()[-2][2]
    return fn

If the decorator has been called from a module outputs ‘module’ and from the method outputs ‘SomeClass’. If called from inside a function returns also the functions name, so to distingish between both cases, you could lookup locals() and globals() to know what the hell are those names: functions or classes.

What do you think?

Edit: The objects may be out of scope so the globals() and locals() thing wouldn’t work…