Return type of "__eq__" incompatible with supertype "object"

[zero323]

Let's say I have a simple class intended for symbolical computations where == and != evaluate to another expression:

class Expr:
    def __eq__(self, other: object) -> 'Expr': ...
    def __ne__(self, other: object) -> 'Expr': ...
    def __add__(self, other: 'Expr') -> 'Expr': ...
    def __sub__(self, other: 'Expr') -> 'Expr': ...

This will result in following errors:

Return type of "__eq__" incompatible with supertype "object"
Return type of "__ne__" incompatible with supertype "object"

As far as I understand Python data model doesn't require rich comparison methods to return bool. Is it Mypy specific requirement or is there something wrong with my class definition?

[ilevkivskyi]

This is because of the return type of object.__eq__ in typeshed. Formally you are right that any return type is accepted at runtime, but changing the static type could hide some "design errors" that are otherwise difficult to catch.

[zero323]

Thank you for a quick response @ilevkivskyi. How would you proceed in case like this? I thought about Any:

class Expr:
    def __eq__(self, other: Any -> Any: ...
    def __ne__(self, other: Any) -> Any: ...

which is a bit suboptimal but seems acceptable. Does it make sense to you?

[ilevkivskyi]

Any is a possible solution. However, using #type: ignore comments on those two particular lines could be more strict, since mypy will catch errors below in code:

class Expr:
    def __eq__(self, other: Any) -> 'Expr':  # type: ignore
        return Expr()
    def __ne__(self, other: Any) -> 'Expr':  # type: ignore
        return 42  # Error: Incompatible return value type (got "int", expected "Expr")

x = Expr() == 0

x.bad  # Error: "Expr" has no attribute "bad"

while with Any such error will be unnoticed by mypy.

EDIT: extended the example.

[JukkaL]

I wonder if the return type of object.__eq__ in typeshed should be object, since the bool return type is not quite correct. The same applies to __lt__ and friends.

[zero323]

Thanks @ilevkivskyi

[exhuma]

@ilevkivskyi Using your suggestion of appending # type: ignore to the line does indeed work quite well. But I find it personally very counter-intuitive, seeing a line with type-hints and an additional type: ignore annotation. It makes it look like the type is completely ignored on that line.

[mvaled]

I got this is issue by looking for: Argument 1 of "eq" incompatible with supertype "object"

from typing import Union

class Expr:
    def __eq__(self, other):
        # type: (Union[Expr, str]) -> bool
        return False

In this case, I tried to put the '# type: ignore' in the same line as the comment type annotation without luck.

[msullivan]

It needs to be on the line with the function declaration