Comments on: Using Decorators to Add Arguments

By: Phillip J. Eby

Phillip J. Eby — Wed, 03 Dec 2008 23:17:19 +0000

Note, by the way, that you can always design your context objects so that the only way to use them is via “with”: e.g., “with Context() as ctx:”, where Context.__enter__ returns the real context object, and the Context() itself is just a dummy class that raises errors if you try to do anything with it, calls close() on __exit__.

By: Heikki Toivonen

Heikki Toivonen — Wed, 03 Dec 2008 17:36:23 +0000

@Brian: Thanks, I will definitely need to take a more careful look of “with”. I dismissed that approach too early I guess, since I haven’t actually used “with” much before (just for locks that already had the needed double underscore methods).

@Cristof: I did consider it (“attach the context to the func object”), but I didn’t like how it looked.

@Love Encounter Flow: I dismissed the inspection approach as being too kludgy.

@Marius: Ah, thanks, I wasn’t aware of that.

By: Marius Gedminas

Marius Gedminas — Wed, 03 Dec 2008 13:43:28 +0000

If you write decorators, you really want to set the __module__ of the inner function too. Things like doctests rely on it. Best use the functools.wraps():

Here goes a massively-blog-comment-distorted-I-expect example:

def ensure_ctx(func):
    @functools.wraps(func)
    def decorate(*args, **kw):
        ...
    return decorate

By: Love Encounter Flow

Love Encounter Flow — Wed, 03 Dec 2008 13:24:58 +0000

i agree with the foregoing posters that this looks a lot like a with statement use case. you may want to consider using contextlib/@contextmanager to simplify the definition of your context handler. as concerns the implicit introduction of local variables (which you are solving by putting the affected names into the method signature)—i’ve tried it before, and i believe it can only be done by recompiling the method source code (i.e. you would have to use inspection to grab the text from the *.py file, then do a superficial parse and add lines that introduce your new variables, exec the source text, and put the result back into the class or module from whence it came). the only other possible solution i’m aware of is fiddling with the bytecodes, which may or may not be easier. this complication is a sad side-effect of python’s strategy to consider a name local when there is a local assignment without a global statement and vice versa.

By: Christof

Christof — Wed, 03 Dec 2008 11:45:11 +0000

Not sure you dismissed this option in your article above but maybe just add ctx to the func in the decorator “func.ctx = Context()“? Usage in the some_func is “some_func.ctx“ but with the decorator before the “def some_func“ it makes this kind of obvious where .ctx may come from.

Not sure how to format code in this comment so I put the code here: http://pastebin.com/f6fd359ed

Guess usage of “with“ may even be better but this seems to work and feels logical in usage I think.

By: Ornitorrinco Enmascarado

Ornitorrinco Enmascarado — Wed, 03 Dec 2008 09:35:37 +0000

I agree with Brian, the “with” statment is a more natural solution.

By: Brian Zimmer

Brian Zimmer — Wed, 03 Dec 2008 06:10:46 +0000

I think the solution you want is the "with" statement available in Python 2.5+. I thought this an interesting post so I responded with more details than I felt appropriate in a comment box.