How do I implement two decorators in Python both of which wouldeventually want to call the calling f

[Devraj]

Hi all,

I am trying to simply my Web application handlers, by using Python
decorators.

Essentially I want to use decorators to abstract code that checks for
authenticated sessions and the other that checks to see if the cache
provider (Memcache in this instance) has a suitable response.

Consider this method definition with the decorators:

@auth.login_required
@cache.clear
def post(self, facility_type_id = None):

auth.login_required checks to see if the user is logged in, otherwise
returns an appropriate error message, or executes the original
function.

cache.clear would check to to see if the cache has a particular key
and drop that, before it executes the calling method.

Both auth.login_required and cache.clear would want to eventually
execute the calling method (post).

From what I've read both, doing what I am doing now would execute the
calling method (post) twice.

My question, how do I chain decorators that end up executing the
calling method, but ensure that it's only called once.

Appreciate any pointers and thanks for your time.

 

[Rafael Durán Castañeda]

You don't need doing something special, each decorator returns a new
function that and only the result function formed by all decorators will
be run. Consider this:

def clear_cache(func):
def decorator(*args, **kwargs):
print "cache cleared"
return func(*args, **kwargs)
return decorator


def login(func):
def decorator(*args, **kwargs):
print "login"
return func(*args, **kwargs)
return decorator

@login
@clear_cache
def post(msg= "POST", *args):
print msg
return args


result = post("POST", "something")
print result

The output will be:

login
cache cleared
POST
('something',)

 

[Chris Rebert]

Hi all,

I am trying to simply my Web application handlers, by using Python
decorators.

Essentially I want to use decorators to abstract code that checks for
authenticated sessions and the other that checks to see if the cache
provider (Memcache in this instance) has a suitable response.

Consider this method definition with the decorators:

@auth.login_required
@cache.clear
def post(self, facility_type_id = None):

auth.login_required checks to see if the user is logged in, otherwise
returns an appropriate error message, or executes the original
function.

cache.clear would check to to see if the cache has a particular key
and drop that, before it executes the calling method.

Both auth.login_required and cache.clear would want to eventually
execute the calling method (post).

calling method (post) twice.

That's incorrect unless the decorators you're using are weird.

My question, how do I chain decorators that end up executing the
calling method, but ensure that it's only called once.

That's how it works normally; decorators stack (and order is therefore
important). With normal wrapping decorators, only the first decorator
gets access to the original function and is able to call it.
Subsequent decorators only get access to the already-wrapped function.

Example:

def decorator_A(func):
def decorated(*args, **kwds):
print "In decorator A"
return func(*args, **kwds)
return decorated

def decorator_B(func):
def decorated(*args, **kwds):
print "In decorator B"
return func(*args, **kwds)
return decorated

@decorator_B
@decorator_A
def myfunc(arg):
print "hello", arg
In decorator B
In decorator A
hello bob


Notice that myfunc() only got executed once.

Cheers,
Chris

 

[Peter Otten]

Hi all,

I am trying to simply my Web application handlers, by using Python
decorators.

Essentially I want to use decorators to abstract code that checks for
authenticated sessions and the other that checks to see if the cache
provider (Memcache in this instance) has a suitable response.

Consider this method definition with the decorators:

@auth.login_required
@cache.clear
def post(self, facility_type_id = None):

auth.login_required checks to see if the user is logged in, otherwise
returns an appropriate error message, or executes the original
function.

cache.clear would check to to see if the cache has a particular key
and drop that, before it executes the calling method.

Both auth.login_required and cache.clear would want to eventually
execute the calling method (post).

From what I've read both, doing what I am doing now would execute the
calling method (post) twice.

My question, how do I chain decorators that end up executing the
calling method, but ensure that it's only called once.

You typically don't need to do anything special for the above to work:
.... print "decorator v, wrapping", f.__name__, "into a"
.... def a(*args, **kw):
.... print "calling", f.__name__, "from a"
.... return f(*args, **kw)
.... return a
........ print "decorator w, wrapping", f.__name__, "into b"
.... def b(*args, **kw):
.... print "calling", f.__name__, "from b"
.... return f(*args, **kw)
.... return b
........ @w
.... def f(s):
.... print s
....
decorator w, wrapping f into b
decorator v, wrapping b into acalling b from a
calling f from b
hello

The output shows that w wraps f into b, but v then doesn't get to see the
original f, it wraps b into a. Put another way

@v
@w
def f(): ...

is the same as

def f(): ...

f = v(w(f))

and calling f() now is equivalent to calling a() which may or may not invoke
b() which may or may not invoke the original f().

Translated into your example:

def post(self, facility_type_id = None): ...
post = auth.login_required(cache.clear(post))

The cache should only be cleared after a successful login, and the original
post() will only be invoked after a successful login and with a cleared
cache.

 

[Tim Chase]

That's how it works normally; decorators stack (and order is therefore
important). With normal wrapping decorators, only the first decorator
gets access to the original function and is able to call it.

I'd clarify "first decorator" here as the one closest to the
decorated function which is actually the *last* one in the list
of decorators, but first-to-decorate. In Chris's example below,
decorator_A is the only one that calls myfunc().

Subsequent decorators only get access to the already-wrapped function.

Example:

def decorator_A(func):
def decorated(*args, **kwds):
print "In decorator A"
return func(*args, **kwds)
return decorated

def decorator_B(func):
def decorated(*args, **kwds):
print "In decorator B"
return func(*args, **kwds)
return decorated

@decorator_B
@decorator_A
def myfunc(arg):
print "hello", arg

In decorator B
In decorator A
hello bob


Notice that myfunc() only got executed once.

-tkc