The decorator login_required is passed the function (hello in this case).

So what you want to do is:

def login_required(f):
    # This function is what we "replace" hello with
    def wrapper(*args, **kw):
        args[0].client_session['test'] = True
        logged_in = 0
        if logged_in:
            return f(*args, **kw)  # Call hello
        else:
            return redirect(url_for('login'))
    return wrapper

The positional arguments to the wrapper function come in the args (first argument - *args ) , and the keyword arguments for the method come in kwargs (second argument - **kwargs ).

args is a tuple , where the first element refers to the first positional argument, second element is the second positional argument.

kwargs is a dictionary , where the key is the keyword (for the argument) and the value is the value passed in for that keyword.

Example -

>>> def decor(func):
...     def wrapper(*args, **kwargs):
...             print('args - ',args)
...             print('kwargs - ',kwargs)
...             return func(*args, **kwargs)
...     return wrapper
...
>>> @decor
... def a(*a, **b):
...     print("In a")
...     print(a)
...     print(b)
...
>>> a(1,2,x=10,y=20)
args -  (1, 2)
kwargs -  {'y': 20, 'x': 10}
In a
(1, 2)
{'y': 20, 'x': 10}

You can test whether app.route is sending id as positional argument or keyword argument by printing both args and kwargs and take the correct value. I think it may be coming in as positional argument, if so, it would be the first element of args .

I'm not entirely clear what it is you want, but if you just want to use the decorated function's arguments, then that is exactly what a basic decorator does. So to access say, self.request from a decorator you could do:

def log_request(fn):
    def decorated_get(self):
        logging.debug("request object:", self.request)
        return fn(self)
    return decorated_get

class MyHandler(webapp. RequestHandler):
    @log_request
    def get(self):
        self.response.out.write('hello world')

If you are trying to access the class the decorated function is attached to, then it's a bit tricker and you'll have to cheat a bit using the inspect module.

import inspect

def class_printer(fn):
    cls = inspect.getouterframes(inspect.currentframe())[1][3]
    def decorated_fn(self, msg):
        fn(self,cls+" says: "+msg)
    return decorated_fn

class MyClass():
    @class_printer
    def say(self, msg):
        print msg

In the example above we fetch the name of the class from the currentframe (during the execution of the decorator) and then store that in the decorated function. Here we are just prepending the class-name to whatever the msg variable is before passing it on to the original say function, but you can use your imagination to do what ever you like once you have the class name.

>>> MyClass().say('hello')
MyClass says: hello

This:

@decorate
def my_function(*args):
    pass

is essentially the same as this:

my_function = decorate(my_function)

Therefore, wrapped_function replaces my_function.

That means:

my_function("a")

actually does this:

wrapped_function("a")

So you hand in the argument to wrapped_function already. You can see this looking at the attribute __name__

>>> my_function.__name__
'wrapped_function'

Without decoration __name__ would be my_function.

The syntax for decorators with arguments is a bit different - the decorator with arguments should return a function that will take a function and return another function. So it should really return a normal decorator. A bit confusing, right? What I mean is:

def decorator_factory(argument):
    def decorator(function):
        def wrapper(*args, **kwargs):
            funny_stuff()
            something_with_argument(argument)
            result = function(*args, **kwargs)
            more_funny_stuff()
            return result
        return wrapper
    return decorator

Here you can read more on the subject - it's also possible to implement this using callable objects and that is also explained there.

Usage:

@decorator_factory("Some argument")
def function_to_be_decorated(args):
    print(f"Do something with '{args}'.")

decorator_factory("Some argument") uses the given argument to create a standard, argumentless decorator. So the following block is functionally identical to the one above:

created_decorator = decorator_factory("Some argument")

@created_decorator
def function_to_be_decorated(args):
    print(f"Do something with '{args}'.")

I'm not a fan of this design. @TheBlackCat is right. Don't do this.

If you are to do this, rethink your design. A more sensible one might look like

import functools
from contextlib import suppress

def try_except_response(func):
    @functools.wraps(func)
    def wrapper(*args, fail_silently, **kwargs):
        if fail_silently:
            with suppress(Exception):
                return func(*args, **kwargs)
        else:
            return func(*args, **kwargs)

    return wrapper

The key principle here is KISS.

Note that I'm suppressing Exception, not BaseException, since catching SystemExit and KeyboardInterrupt is almost always a bad idea.

If you want to make fail_silently a default argument, just use another wrapper:

def default_fail_silently(default):
    def decorator(func):
        @functools.wraps(func)
        def wrapper(*args, fail_silently=default, **kwargs):
            return func(*args, fail_silently=fail_silently, **kwargs)
        return wrapper
    return decorator

Then you can do

@default_fail_silently(False)
@try_except_response
def test(a, b, c=1)
    return int(a) + c

This does mean there's more boilerplate, since it exists for each piece of functionality you add, but the logic itself is an order of magnitude simpler.

Modify the decorator to store the categories in an attribute (e.g. _args) of the decorated function:

def check(*args):
    # do something project relevant, so just return True
    return True

def decorate(*categories):
    def wrap(f):
        def wrap_check_categories(*args, **kwargs):
            if check(*categories):
                return f(*args, **kwargs)
            else:
                raise Exception
        wrap_check_categories._args = categories    # <-- store the categories
        return wrap_check_categories
    return wrap

def get_categories(f):
    '''Returns decorator parameters'''
    # ... do some magic here
    return f._args

@decorate('foo', 'bar')
def fancy_func(*args, **kwargs):
    return args, kwargs

def main():
    ## should output ['foo', 'bar']
    print get_categories(fancy_func)

if __name__ == '__main__':
    main()

yields

('foo', 'bar')