Make `@cached_property` settable?

[tmke8]

The documentation notes:

The mechanics of cached_property() are somewhat different from property(). A regular property blocks attribute writes unless a setter is defined. In contrast, a cached_property allows writes.

And mypy has @cached_property special-cased to be settable: https://github.com/python/mypy/blob/ad82257170636871a0062ebe6fb82fb45523f580/mypy/semanal.py#L1508-L1509 So, mypy allows assignments to the property even though __set__ isn't defined in typeshed.

But in pyright it isn't settable, because pyright just follows typeshed. I raised an issue about it: microsoft/pyright#4438 but pyright (somewhat understandably) doesn't want to special-case @cached_property.

So, my proposal is now to add __set__ method to the typestub of @cached_property. Something like this:

class cached_property(Generic[_T]):
    # [...]
    def __set__(self, instance: object, value: _T) -> None: ...

I have confirmed that at runtime, overwriting a cached property seems to work at any time, even if it hasn't been called yet:

>>> from functools import cached_property
>>> class A:
...   @cached_property
...   def c(self):
...     return 0
... 
>>> a = A()
>>> a.c = 3
>>> a.c
3
>>> a = A()
>>> a.c
0
>>> a.c = 2
>>> a.c
2

[AlexWaygood]

This is a bit weird, since the class doesn't actually define a __set__ method at runtime. But I'd be okay with telling a white lie in the stub here; the way cached_property works is quite magical, after all.

[tmke8]

@erictraut do you have an opinion on this? It's only be the non-mypy type checkers that would affected by this, because, as mentioned, mypy already has special-cased support for setting @cached_property.

[erictraut]

I don't have enough knowledge of the internals of @cached_property to have an opinion here. If @AlexWaygood thinks this is the best approach, I trust his judgement.

[srittau]

The reason this works is because a descriptor that doesn't define __set__ actually allows itself to be replaced in the instance:

from functools import cached_property

class Foo:
    @cached_property
    def bar(self):
        return 42
    
f = Foo()
print("bar" in f.__dict__)  # False
f.bar = 33
print("bar" in f.__dict__)  # True

So "setting" a cached_property is a bit of a hack, since it's not explicitly allowed in the implementation and more a side-effect of how the descriptor protocol works. That said, I can definitely see the use case for cached_property, so I'm fine with the hack in typeshed.