Calling another member decorator from another member decorator in Python 3

Question

I am trying to re-use a member function decorator for other member function decorator but I am getting the following error:

'function' object has no attribute '_MyClass__check_for_valid_token'

Basically I have a working decorator that checks if a user is logged in (@LOGIN_REQUIRED) and I would like to call this first in the @ADMIN_REQUIRED decorator (so the idea is to check that the user is logged in with the existing @LOGIN_REQUIRED decorator and then add some specific validation to check if the logged user is an Administrator in the @ADMIN_REQUIRED decorator.

My current code is like this:

class MyClass:
    def LOGIN_REQUIRED(func):
            @wraps(func)
            def decorated_function(self, *args, **kwargs):
                # username and token should be the first parameters
                # throws if not logged in
                self.__check_for_valid_token(args[0], args[1])
                return func(self, *args, **kwargs)
            return decorated_function
    
    @LOGIN_REQUIRED
    def ADMIN_REQUIRED(func):
        @wraps(func)
        def decorated_function(self, *args, **kwargs):
            is_admin = self.check_if_admin()

            if not is_admin:
                raise Exception()

            return func(self, *args, **kwargs)
        return decorated_function
        
    @ADMIN_REQUIRED
    def get_administration_data(self, username, token):
        # return important_data
        # currently throws 'function' object has no attribute '_MyClass__check_for_valid_token'

Do you have any idea how could I get this to work?

---

Some notes based on the comments and answers for clarification:

1. The method __check_for_valid_token name can be changed to not run into name mangling issues. I was just using double underscore because it was a method supposedly only accessible by the class itself (private).
2. There is no inheritance in "MyClass".
3. The @LOGIN_REQUIRED code must run before the @ADMIN_REQUIRED code (as that is what someone expects, at least in my case).

Answer 1

I think this is possible, with two caveats; first, the decorator will have to move outside the class, and second, some adaptation will be required in regards to the name mangling. Let's tackle the first - first.

Moving some functions

Decorating a decorator directly may seem intuitive, but it probably won't result with what you want. You can, however, decorate an inner function - just like how @wraps is used. Due to how python parses code, the outer decorator will have to be defined outside (and before) the class, otherwise you'll get a NameError. The code should look something like this:

def _OUTER_LOGIN_REQUIRED(func):
    @wraps(func)
    def decorated_function(self, *args, **kwargs):
        self.__check_for_valid_token(args[0], args[1])
            return func(self, *args, **kwargs)
        return decorated_function
    [Notice no code-changes to this function (yet)]

class MyClass:
    # The following line will make the transition seamless for most methods
    LOGIN_REQUIRED = _OUTER_LOGIN_REQUIRED

    def ADMIN_REQUIRED(func):
        @wraps(func)
        @_OUTER_LOGIN_REQUIRED  # <-- Note that this is where it should be decorated
        def decorated_function(self, *args, **kwargs):
        ... [the rest of ADMIN_REQUIRED remains unchanged]

    @ADMIN_REQUIRED
    def get_administration_data(self, username, token):
    ... [this should now invoke LOGIN_REQUIRED -> ADMIN_REQUIRED -> the function]

    @LOGIN_REQUIRED
    def get_some_user_data(self, ...):
    ... [Such definitions should still work, as we added LOGIN_REQUIRED attribute to the class]

If such a change is acceptable so-far, let's move on to

Name Mangling

As the name of __check_for_calid_token function is mangled (as its name starts with a dunder), you'll have to decide how to tackle it. There are two options:

1. If there is no restriction, simply shorten the dunder to a single underscore (or rename as you like - as long as it doesn't start with more than one underscore).
2. If the name mangling is important, you'll have to change the call in _OUTER_LOGIN_REQUIRED like so:

def decorated_function(self, *args, **kwargs):
    self._MyClass__check_for_valid_token(args[0], args[1])

This might affect inheritance, and should be tested thoroughly.

Summary

I've tested around this a bit on python 3.9, and it seems to work quite well. I noticed that login errors are raised before admin errors, as I assume is desired. Still, I only poked around in a shallow manner, and while I can't think of a reason for this to misbehave, I strongly recommend testing this thoroughly before committing to this method (especially if the code includes inheritance, which I didn't even touch).

I hope this works for you, and if it doesn't - let us know where it breaks, and how.

Answer 2

The sanest way to do this is to keep both decorators seperate and apply them both:

from functools import wraps

def LOGIN_REQUIRED(func):
    @wraps(func)
    def decorated_function(self, *args, **kwargs):
        # username and token should be the first parameters
        # throws if not logged in
        print("checking login")
        self._MyClass__check_for_valid_token(args[0], args[1])
        return func(self, *args, **kwargs)
    return decorated_function
    
def ADMIN_REQUIRED(func):
    @wraps(func)
    def decorated_function(self, *args, **kwargs):
        print("checking if admin")
        is_admin = self.check_if_admin()

        if not is_admin:
            raise Exception()

        return func(self, *args, **kwargs)
    return decorated_function


class MyClass:
    def __check_for_valid_token(self, username, token):
        return True
    def check_if_admin(self):
        return True
    @LOGIN_REQUIRED
    @ADMIN_REQUIRED
    def get_administration_data(self, username, token):
        # return important_data
        return 42

Note, the decorators are defined outside of the class, because they are not methods. They should have never been defined inside the class to begin with. Also note, you seem to want to use double-underscore name-mangling, so you are going to have to manually use _MyClass__check_for_valid_token instead of relying on the compile-time transformation of __check_for_valid_token. Probably, it is even better to simply not use double-underscore name mangling and use a single underscore.

If you really want something that applies both, then create a third, helper decorator:

def LOGIN_AND_ADMIN_REQUIRED(func):
    return LOGIN_REQUIRED(ADMIN_REQUIRED(func))


class MyClass:        
    @LOGIN_AND_ADMIN_REQUIRED
    def get_administration_data(self, username, token):
        # return important_data
        ...

But if you insist on making ADMIN_REQUIRED do both, then you can just:

def ADMIN_REQUIRED(func):
    # func = LOGIN_REQUIRED(func) here, ADMIN_REQUIRED would happen first
    @wraps(func)
    def decorated_function(self, *args, **kwargs):
        print("checking if admin")
        is_admin = self.check_if_admin()

        if not is_admin:
            raise Exception()

        return func(self, *args, **kwargs)

    return LOGIN_REQUIRED(decorated_function)

---

Note, if you really want to, you can nest the decorator definitions inside the class. This is ultimately a matter of style, since you are not prevented from doing it, but now you should really just use the explicit double decoration syntax, otherwise, you cannot refer to the other decorator because the class block doesn't create an enclosing scope:

class MyClass:
    def LOGIN_REQUIRED(func):
        @wraps(func)
        def decorated_function(self, *args, **kwargs):
            # username and token should be the first parameters
            # throws if not logged in
            print("checking login")
            self.__check_for_valid_token(args[0], args[1])
            return func(self, *args, **kwargs)
        return decorated_function

    def ADMIN_REQUIRED(func):
        @wraps(func)
        def decorated_function(self, *args, **kwargs):
            print("checking if admin")
            is_admin = self.check_if_admin()

            if not is_admin:
                raise Exception()

            return func(self, *args, **kwargs)
        return decorated_function

    def __check_for_valid_token(self, username, token):
        return True

    def check_if_admin(self):
        return True

    @LOGIN_REQUIRED
    @ADMIN_REQUIRED
    def get_administration_data(self, username, token):
        # return important_data
        return 42

Note, if it is inside the class definition, you can just use __check_for_valid_token in LOGIN_REQUIRED.

---

Answer 3

If you want to decorate a decorator, you could add another wrapping layer to LOGIN_REQUIRED

class MyClass:
    def LOGIN_REQUIRED(dec):
        def decwrapper(func):
            wrapped = dec(func)
            def decorated_function(self, *args, **kwargs):
                # username and token should be the first parameters
                # throws if not logged in
                self.__check_for_valid_token(args[0], args[1])
                return wrapped(self, *args, **kwargs)
            return decorated_function
        return decwrapper

If you want to keep your decorator definitions as is, you have to move the @LOGIN_REQUIRED decoration from def ADMIN_REQUIRED to def get_administration_data()

@LOGIN_REQUIRED
@ADMIN_REQUIRED
    def get_administration_data(self, ar1, ar2):
       ...