Misleading error report when we implement __getattr__ and a property raises an AttributeError exception

[FabriceSalvaire]

Feature or enhancement

Proposal:

There are many reports on the web about this behaviour.

But look at this code and how Python 3.13 reacts:

class Foo:

    def __init__(self):
        self.bar = None

    def __getattr__(self, name):
        print(f'catched {name}')

    @property
    def aproperty(self):
        self.bar.foo

    def afunc(self):
        self.bar.foo

_ = Foo()

_.afunc()
# Traceback (most recent call last):
#   File "property-issue.py", line 18, in <module>
#     _.afunc()
#     ~~~~~~~^^
#   File "property-issue.py", line 14, in afunc
#     self.bar.foo
# AttributeError: 'NoneType' object has no attribute 'foo'

_.aproperty
# catched aproperty

It looks weird to me. Why Python should react differently for the same code depending on it is defined as a func or a property ?
Moreover, I would expect __getattr__ catch AttributeError only on Foo.__dict__.
And a better error reporting and a note on the documentation about this behaviour.

Has this already been discussed elsewhere?

No response given

Links to previous discussion of this feature:

See #69171 #90143
And especially #52968

[picnixz]

I don't have time now to reply exactly on this, but this is the expected behaviour because aproperty behaves as a descriptor whose getter raises AttributeError, so we fallback to __getattr__:

Called when the default attribute access fails with an AttributeError (either __getattribute__() raises an AttributeError because name is not an instance attribute or an attribute in the class tree for self; or __get__() of a name property raises AttributeError).

[nybblista]

Why Python should react differently for the same code depending on it is defined as a func or a property?

Python does not react differently for the same code. However, if you call the __get__ method directly from the property object, you will get
the same result as if you called _.afunc().

Foo.aproperty.__get__(_)

However, what happend here is that the Python followed the descriptor protocol to execute Foo.aproperty.__get__ so if there is an AttributeError exception was raised, fallback to __getattr__.

self.bar.foo

If your point is about the foo attribute, this is because of the propagation or bubbles up of the AttributeError exception that is raised inside the __get__, which in turn will signal the fallback process. In the following example, we have handled the exception which is stopped the fallback to __getattr__.

@property
def aproperty(self):
    try:
        self.bar.foo
    except AttributeError as err:
        print(err)

The difference:

1. _.afunc(): In this case, there is unhandeld AttributeError exception raised. However, because it is a normal method, there is no fallback action.
2. _.aproperty: In this case, aproperty followed the descriptor protocol, which implicitly fallback to __getattr__ if AttributeError exception raised.

[picnixz]

Thank you for completing my explanation. I'm closing this issue as not an issue.