Abstract Properties & Overloaded method has both abstract and non-abstract variants

[engnadeau]

Expected Behaviour

• Ability to type check abstract property getters and setters
• The intention is to have an interface-like design using properties

Actual Behaviour & Repro Case

Python Code

from abc import abstractmethod


class A:
    @property # error occurs here
    @abstractmethod
    def foo(self) -> int:
        pass

    @foo.setter  # type: ignore
    @abstractmethod
    def foo(self, value: int) -> None:
        pass

Mypy CLI

mypy --strict

Result

error: Overloaded method has both abstract and non-abstract variants

Notes

• The error message is defined here:

  mypy/mypy/messages.py

  Lines 74 to 75 in a1ace48

  	INCONSISTENT_ABSTRACT_OVERLOAD = \
  	'Overloaded method has both abstract and non-abstract variants'

• The error is thrown from here:

  mypy/mypy/checker.py

  Lines 329 to 330 in 936ceac

  	if num_abstract not in (0, len(defn.items)):
  	self.fail(messages.INCONSISTENT_ABSTRACT_OVERLOAD, defn)

• Removing # type: ignore from @foo.setter causes mypy to throw error: Decorated property not supported, just as in Decorated property not supported #1362

Related Issues

• Decorated property not supported #1362

Current Solution

• Silence the error with @property # type: ignore

[Netzeband]

It seems that version 0.750 still have this bug. Do you have any ideas how to solve it?

[veox]

py-evm uses this workaround for now.

[pipermerriam]

Here's a link that works to the py-evm workaround:

https://github.com/ethereum/py-evm/blob/7350ac395c27c448fe6136234d61d9a166bb26c1/eth/abc.py#L1232-L1240

[solstice333]

I'm running mypy 0.782 on OSX 10.13.6.

Furthermore, if you use #type:ignore on both the getter and setter abstract properties to suppress the error message, and only implement the getter in the implementing subclass, you never get a mypy error if you never try to use the setter. For instance if I have

from abc import ABC, abstractmethod


class C(ABC):
   @property # type:ignore
   @abstractmethod
   def x(self) -> int:
      pass

   @x.setter # type:ignore
   @abstractmethod
   def x(self, val: int) -> None:
      pass
   

class D(C):
   def __init__(self) -> None:
      self._x = 0

   @property
   def x(self) -> int:
      return self._x


def main() -> None:
   d = D()
   print(d.x)


if __name__ == '__main__':
   main()

I get

$ python3 -m mypy --strict bar.py && python3 bar.py
Success: no issues found in 1 source file
0

I would expect for mypy to say "hey, implement an x.setter in class D". Removing #type:ignore on the getter abstract property results in

bar.py:5: error: Overloaded method has both abstract and non-abstract variants

as the OP already mentioned. Removing the #type:ignore on the setter abstract property results in

bar.py:10: error: Decorated property not supported

The only workaround that seems to make sense is to avoid using properties altogether, and stick with abstract methods:

from abc import ABC, abstractmethod


class C(ABC):
   @abstractmethod
   def get_x(self) -> int:
      pass

   @abstractmethod
   def set_x(self, val: int) -> None:
      pass
   

class D(C):
   def __init__(self) -> None:
      self._x = 0

   def get_x(self) -> int:
      return self._x


def main() -> None:
   d = D()


if __name__ == '__main__':
   main()

which results in:

bar.py:23: error: Cannot instantiate abstract class 'D' with abstract attribute 'set_x'

[ktbarrett]

Seems that using abstractproperty works as intended and avoids the error messages.
@solstice333 This approach errors if only the setter and not the getter are used. It's now properly type checked because it doesn't use type: ignore.

class A(ABC):
    @abstractproperty
    def a(self) -> int:
        ...        
    @a.setter
    def a(self, new_a: int) -> None:
        ...

[aspacca]

abstractproperty is deprecated

class abstractproperty(property):
    """A decorator indicating abstract properties.

    Deprecated, use 'property' with 'abstractmethod' instead:

        class C(ABC):
            @property
            @abstractmethod
            def my_abstract_property(self):
                ...

    """

[jgillard]

I hit this today with code similar to the repro, and removing @abstractmethod from the setter fixed it. i.e. only the getter is now decorated with @abstractmethod.

I got this idea from the 2nd code block here in the docs: https://docs.python.org/3.10/library/abc.html#abc.abstractproperty

[ilevkivskyi]

The original example now works without any type-ignores on master. Probably was fixed by the same PR that fixed #1362. Also the example in the comments now correctly gives Read-only property cannot override read-write property.

[rhshadrach]

Edit: I misread and thought #4165 (comment) was from long ago; I now see it is only just over a month old. I think there is nothing to do here; sorry for the noise.

We're seeing this issue pop up again with 0.971 and it appears to be subsequently fixed with 0.981. Haven't tried other versions; perhaps a test should be added?

Good behavior (mypy 0.981): pandas-dev/pandas#48943
Bad behavior (mypy 0.971): pandas-dev/pandas#48959

[warsaw]

Is this issue actually fixed? I've run into this same problem with mypy 1.3.0. Here's a reproducible example.

% mypy --version
mypy 1.3.0 (compiled: yes)
% mypy /tmp/foo.py
/tmp/foo.py: note: In member "default" of class "Abstract":
/tmp/foo.py:7:6: error: Overloaded method has both abstract and non-abstract variants  [misc]
        @property
         ^
Found 1 error in 1 file (checked 1 source file)

And here is /tmp/foo.py:

from abc import ABC, abstractmethod


class Abstract(ABC):
    """An abstract thing."""

    @property
    @abstractmethod
    def default(self) -> str:
        """The default code."""

    @default.setter
    @abstractmethod
    def default(self, code: str) -> None:
        """Set the code."""

    @default.deleter
    @abstractmethod
    def default(self) -> None:
        """Reset the code."""

[hauntsaninja]

Looks like it got fixed for setters, but not deleters