strategy for simple attribute that becomes @property on a subclass

[zzzeek]

as I'm from fairly old school Python where Python is not Java told us to not write getters and setters, upgrade to @property only as needed, I tend to use (a variant of) this pattern a lot:

from typing import cast


class MyThing:
    some_attr: bool

    def __init__(self, some_attr: bool):
        self.some_attr = some_attr

class MySubThing(MyThing):
    @property
    def some_attr(self) -> bool:
        return cast(bool, self.__dict__['some_attr'])

    @some_attr.setter
    def some_attr(self, value: bool) -> None:
        self.__dict__['some_attr'] = value

that is, for a family of classes, I don't want to impose the expense of @property on the base class, I just want those particular subclasses that have some dynamic nature to the attribute to use a descriptor, which above is @property though in practice I have other descriptors for this kind of thing also such as memoization descriptors.

anyway it seems like the above pattern isn't possible without putting the @property part of it inside of a negative TYPE_CHECKING block or otherwise type:ignore, as mypy does not allow the above pattern:

 mypy test3.py 
test3.py:11: error: Signature of "some_attr" incompatible with supertype "MyThing"  [override]
test3.py:12: error: Signature of "some_attr" incompatible with supertype "MyThing"  [override]
Found 2 errors in 1 file (checked 1 source file)

Looking at some common workarounds, @property itself is not generic and doesn't seem to play well with a generic descriptor in any case:

from typing import cast, TypeVar, Any
from typing import Protocol, overload

_T = TypeVar("_T")


class UpgradeDescriptor(Protocol[_T]):
    @overload
    def __get__(self, instance: None, owner: Any) -> _T:
        ...

    @overload
    def __get__(self, instance: object, owner: Any) -> _T:
        ...

    def __set__(self, instance: Any, value: _T) -> None:
        ...

    def __delete__(self, instance: Any) -> None:
        ...


class MyThing:
    some_attr: UpgradeDescriptor[bool]

    def __init__(self, some_attr: bool):
        self.some_attr = some_attr


class MySubThing(MyThing):
    @property
    def some_attr(self) -> bool:
        return cast(bool, self.__dict__["some_attr"])

    @some_attr.setter
    def some_attr(self, value: bool) -> None:
        self.__dict__["some_attr"] = value

test3.py:31: error: Signature of "some_attr" incompatible with supertype "MyThing"  [override]
test3.py:32: error: Signature of "some_attr" incompatible with supertype "MyThing"  [override]
Found 2 errors in 1 file (checked 1 source file)

I can swap out @property for my own descriptor class to make the above pattern work, but I dont like the above pattern anyway because it's lying about MyThing.some_attr being a descriptor in all cases.

that leaves us with the most succinct pattern is that we need two type-ignores:

from typing import cast


class MyThing:
    some_attr: bool

    def __init__(self, some_attr: bool):
        self.some_attr = some_attr

class MySubThing(MyThing):
    @property    # type: ignore[override]
    def some_attr(self) -> bool:    # type: ignore[override]
        return cast(bool, self.__dict__['some_attr'])

    @some_attr.setter
    def some_attr(self, value: bool) -> None:
        self.__dict__['some_attr'] = value

is that the best we can do ?

[Akuli]

@property should just work, and this is a known bug in mypy: python/mypy#4125

[zzzeek]

well there you have it. I will mark all my type ignores with that issue number. thanks!