Can a method be called in the __getattribute__ method?

The answer is yes, but very, very, very carefully...

The method __getattribute__together with its brother __setattr__are perhaps two of the most complicated special methods to implement and in which more care must be taken.

The problem with __getattribute__is almost always the same, we implement it, we think everything is perfect, we execute and boom! infinite recursion.

The cause and its explanation are really very simple, but even knowing it perfectly, it is easy to make a mistake. What must always be marked on fire is:

The method __getattribute__is always the first method called when accessing an attribute or method ( it doesn't matter to the language in this case ) of an object.

It is therefore the entry point to resolve access to attributes through "dot notation", if it does not find the attribute it delegates to the other methods of the chain until it ends with __getattr__whether it is implemented.

The cause of infinite recursion is whenever we call a method or access an attribute from it __getattribute__directly or indirectly. If __getattribute__an attempt is made to access an attribute of the instance from within itself self.atributo, for example, when resolving , self.atributoit is called self.__getattribute__("atributo"), within which it attempts to access self.atributo, which again calls self.__getattribute__("atributo")...

The way to avoid it is to delegate to the method __getattribute__of a parent class the obtaining of the reference to the attribute/method, ultimately it will be object.__getattribute__if we do not inherit from anything. The normal thing is to use super()for it, which returns a proxy object to the parent method that it touches, according to MRO, that we can use to call it.

Case 1

class User:
    def __init__(self, user):
        self.user = user

    def __getattribute__(self, name):
        x = self.user
        print(x)
        return super().__getattribute__(name)

>>> user = User("FJSevilla")
>>> user.user
RecursionError: maximum recursion depth exceeded

Bad, very bad, it causes ( ) x = self.userto be called again from itself...__getattribute__self.__getattribute__("user")

Related question:

• RecursionError: maximum recursion depth exceeded

case 2

class User:
    def __init__(self, user):
        self.user = user

    def __getattribute__(self, name):
        x = super().__getattribute__("user")
        print(x)
        return super().__getattribute__(name)

>>> user = User("FJSevilla")
>>> user.user
"FJSevilla"

Well, by delegating to the parent method we avoid the recursive call.

case 3

class User:
    def __init__(self, user):
        self.user = user

    def authenticate_user(self):
        return "FJSevilla"

    def foo(self):
        pass

    def __getattribute__(self, name):
        if name not in ['create_user', 'authenticate_user']:
            x = super().__getattribute__('authenticate_user')()
            print(x)

        return super().__getattribute__(name)

>>> user = User("FJSevilla")
>>> user.foo
"FJSevilla"

No problem, as before, the resolution of the method is delegated to the parent self.autentificate_userand there is no recursive call.

case 4

class User:
    def __init__(self, user):
        self.user = user

    def authenticate_user(self):
        return self.user

    def foo(self):
        pass

    def __getattribute__(self, name):
        if name not in ['create_user', 'authenticate_user']:
            x = super().__getattribute__('authenticate_user')()
            print(x)

        return super().__getattribute__(name)

>>> user = User("FJSevilla")
>>> user.foo
RecursionError: maximum recursion depth exceeded in comparison

Again... We have only changed:

def authenticate_user(self):
    return "FJSevilla"

by:

def authenticate_user(self):
    return self.user    # <<<<<<<<<<<<<

but the error is very similar to case 1, only that in this case the access to an attribute from __getattribute__is not directly, it is the method that super().__getattribute__returns you that causes it to be called __getatributte__again because of return self.user.

You don't show the implementation of the method authenticate_userbut I can say with some certainty that said method accesses attributes or methods of the instance at some point and therefore makes use of __getattribute__.

Case 5

class User:
    def __init__(self, user):
        self.user = user

    def authenticate_user(self):
        return self.user

    def foo(self):
        pass

    def __getattribute__(self, name):
        if name not in ['create_user', 'authenticate_user', "user"]:
            #                                               ^^^^^^
            x = super().__getattribute__('authenticate_user')()
            print(x)

        return super().__getattribute__(name)

    >>> user = User("FJSevilla")
    >>> user.foo
    "FJSevilla"

case 6

class User:
    def __init__(self, user):
        self.user = user

    def authenticate_user(self):
        return self.user

    def foo(self):
        pass

    def __getattribute__(self, name):
        if name not in ['create_user', 'authenticate_user', "user"]:
            #                                               ^^^^^^
            x = super().__getattribute__('authenticate_user')()
            print(x)

        return super().__getattribute__(name)

    >>> user = User("FJSevilla")
    >>> user.foo
    "FJSevilla"

case 7

class User:
    def __init__(self, user):
        self.user = user  # Mal

    def get_user(self):
        return self.user

    def authenticate_user(self):
        return super().__getattribute__("get_user")() # Bien

    def foo(self):
        pass

    def __getattribute__(self, name):
        if name not in ['create_user', 'authenticate_user']:
            x = super().__getattribute__('authenticate_user')() # Bien
            print(x)

        return super().__getattribute__(name)

    >>> user = User("FJSevilla")
    >>> user.foo
    RecursionError: maximum recursion depth exceeded in comparison

Case No.

Depending on the specific implementation, there will be many possible solutions, but the idea of ​​all of them is always the same: to avoid at all costs that anything you call or reference in __getattribute__end up at any time also calling self.__getattibute__without there being a short circuit at some point .

What about builtins and operators that use instance methods?

class User:
    def __init__(self, user):
        self.user = user

    def authenticate_user(self):
        return str(self)

    def foo(self):
        pass

    def __getattribute__(self, name):
        if name not in ['create_user', 'authenticate_user', 'user']:
            x = super().__getattribute__('authenticate_user')()
            print(x)
        return super().__getattribute__(name)

    def __str__(self):
        return self.user

>>> user = User("FJSevilla")
>>> user.foo
FJSevilla

One might think that since it str(self)calls self.__str__we would again have the problem that concerns us... Well, no str, implementadoin C, it does not directly reference the method using the implementation of __getattribute__the instance, avoiding the problem. The same would happen with repr, sorted, print, operators like ==( __eq__), !=( __ne__), etc. This is the reason why __str__o __repr__, __hash__, etc should not be called directly, but through its builtins.

That yes, it does not protect us from __str__accessing attributes that cause the recursive call in the implementation of the own, if in the previous example we change:

if name not in ['create_user', 'authenticate_user', 'user']:

by:

if name not in ['create_user', 'authenticate_user']:

we roll it again.