Chaining decorators that are defined as classes?

Question

For the sake of learning, I'm trying to chain decorators that are defined by classes. I read this question about decorators, which has a lot of good information about chaining them with functions. They also link to the documentation, but I'm trying to figure out simpler examples.

Basically, I'm trying to mimic similar behaviour using classes. Here is my first decorator definition, which works perfectly.

class square_result(object):
    def __init__(self, f):
        pass

def __call__(self, x, y):
        return (x+y)**2

@square_result
def add_two_numbers(x, y):
    return x + y

print(add_two_numbers(2,5)) #Outputs 49, as expected

Then, I add another decorator to create this code snippet:

class square_result(object):
    def __init__(self, f):
        pass

    def __call__(self, x, y):
        return (x+y)**2

class append_abc(object):
    def __init__(self, f):
        pass

    def __call__(self, *args):
        return str(*args) + "abc"

@append_abc
@square_result
def add_two_numbers(x, y):
    return x + y

print(add_two_numbers(2,5))
#Ideally, this should print "49abc" but prints "(2,5)abc" instead

what is the proper way of doing this? I guess what I want to do is create a decorator in the form of a class that takes the output of the function it decorates (in this case square_result) and appends "abc" to it.

I know that when I add a decorator to my code, the add_two_numbers() function is compiled and that function object is passed to the square_result class, which does something to create a function-like object which is substituted for the original add_two_numbers(). However, I'm not sure how to chain this.

The version you posted is an error. Take out the `*` from `str(*args)` and it does what you said. — agf, Mar 19 '12 at 19:23
So change that line to ``return str(args) + "abc"``? That doesn't work and still produces the same result for me. — Ricardo Altamirano, Mar 19 '12 at 19:26

score 2 · Accepted Answer · answered Mar 19 '12 at 19:25

This does what you want:

class square_result(object):
    def __init__(self, f):
        pass

    def __call__(self, x, y):
        return (x+y)**2

class append_abc(object):
    def __init__(self, f):
        self.f = f

    def __call__(self, *args):
        return str(self.f(*args)) + "abc"

@append_abc
@square_result
def add_two_numbers(x, y):
    return x + y

print(add_two_numbers(2,5))

You need to actually run the inner function in the decorator if you want to use its output in the result of the decorator.

I didn't edit your first decorator, as it does what you want, but it actually isn't useful as a decorator. Since its output is not related in any way to the function it's decorating, it's just replacing the function. If you wanted to replace the function with that class, the way to do it would be

class square_result(object):
    def __call__(self, x, y):
        return (x+y)**2

# this has no effect at all after the reassignment    
def add_two_numbers(x, y):
    return x + y

add_two_numbers = square_result()

PEP8 also suggests CamelCase for your class names (SquareResult).

Excellent. I just added found that and added it to my own question, but I reverted it so I could accept it and give you the points. I'll accept this as soon as the delay expires. — Ricardo Altamirano, Mar 19 '12 at 19:27
Thanks for the tip on my first class too. Is my updated code the correct way of making a ``square_result`` decorator? — Ricardo Altamirano, Mar 19 '12 at 19:41
@pythonscript Yes, but I reverted it because the answers only make sense with both incorrect. — agf, Mar 19 '12 at 19:45
My apologies. I think it's all working now, so I'll leave the questino/comments the way they are. — Ricardo Altamirano, Mar 19 '12 at 19:46

score 1 · Answer 2 · answered Mar 19 '12 at 19:28

square_result doesn't "decorate" the add_two_numbers result, but overrides it (doing the addition as well as the squaring). It should instead treat the decorated function the same way that append_abc does, by storing it and then making use of the decorated function in its own implementation. Thus:

class square_result(object):
    def __init__(self, f):
        self.function = f

    def __call__(self, *args):
        return self.function(*args)**2

class append_abc(object):
    def __init__(self, f):
        self.function = f

    def __call__(self, *args):
        return str(self.function(*args)) + "abc"

@append_abc
@square_result
def add_two_numbers(x, y):
    return x + y

print(add_two_numbers(2,5))

Chaining decorators that are defined as classes?

2 Answers2