Problems with method_cache on __getitem__ and __getattr__

[alejandro-rivera]

Using method_cache on the getitem and getattr magic methods does not work as expected.

On python2, method_cache on getitem works fine, but not on getattr: no cached values are returned.

On python3, method_cache fails to return cached values on both getitem and getattr.
#4 adds a test that tries to highlight the issue. Hopefully a solution to this problem can be found (making this test pass!).

Regards.

[jaraco]

Thanks for this. There is a possible workaround, bypassing the specialness of __getattr__:

def __getattr__(self, item):
    return self._getattr(item)

@method_cache
def _getattr(self, item):
    ...

But the whole point of method_cache is to provide a simple, clean decorator. If the workaround is as messy as the code it's intended to replace, it's hardly worthwhile.

I suspect the issue is that those methods must in fact be installed on the class and not on the instance, as method_cache does. I'll see what I can do about that.

[jaraco]

In the Class Instances section of the standard type hierarchy, the docs say this:

If no class attribute is found, and the object’s class has a getattr() method, that is called to satisfy the lookup.

Although it's not pointedly specific, it does imply that the __getattr__ is always called on the class and not on the instance, which is consistent with your finding. In that case, the technique used by method_cache, setting a callable on the instance, isn't viable for __getattr__.

Similarly, the docs on special method names indicate:

For instance, if a class defines a method named getitem(), and x is an instance of this class, then x[i] is roughly equivalent to type(x).getitem(x, i).

Again, the docs explicitly indicate that although these methods are typically described as instance methods (with a self parameter), they're treated as class methods.

And if we dig into the Python 2.7 docs on special method lookup for new style classes, it's clearly stated:

For new-style classes, implicit invocations of special methods are only guaranteed to work correctly if defined on an object’s type, not in the object’s instance dictionary.

That nuance is also present in the Python 3 docs.

Therefore, the technique employed by method_cache is simply not viable for special methods.