Abstract class properties that are classes incorrectly reported in assignments

[Dr-Irv]

• Are you reporting a bug, or opening a feature request?
  I believe this is a bug.

• Please insert below the code you are checking with mypy

from abc import ABC, abstractmethod
from typing import Type


class ISolution(ABC):
    @abstractmethod
    def __init__(self, b: int):
        pass

    @abstractmethod
    def func1(self, a: int) -> int:
        pass


class MySolution(ISolution):
    def __init__(self, b: int):
        self._b = b

    def func1(self, a: int) -> int:
        return a + self._b


class IHolder(ABC):
    @property
    @classmethod
    @abstractmethod
    def SolutionClass(cls) -> Type[ISolution]:
        pass

    # SolutionClass: Type[ISolution]

    @abstractmethod
    def __init__(self, c: int):
        pass

    @abstractmethod
    def cval(self) -> int:
        pass


class Main(IHolder):
    SolutionClass = MySolution

    def __init__(self, c: int):
        self._c = c

    def cval(self) -> int:
        return self._c


def check(holderclass: Type[IHolder], a: int, b: int, c: int) -> bool:
    holder = holderclass(c)
    solclass: Type[ISolution] = holderclass.SolutionClass
    return solclass(b).func1(a) == holder.cval()


print("should be true ", check(Main, 5, 5, 10))
print("should be false ", check(Main, 3, 4, 10))

• What is the actual behavior/output?

classprop.py:53: error: Incompatible types in assignment (expression has type "Callable[[], Type[ISolution]]", variable has type "Type[ISolution]")

This is referring to the line:

    solclass: Type[ISolution] = holderclass.SolutionClass

• What is the behavior/output you expect?
  No error to be reported.

Note. If you comment out

    @property
    @classmethod
    @abstractmethod
    def SolutionClass(cls) -> Type[ISolution]:
        pass

and then uncomment

    SolutionClass: Type[ISolution]

then mypy says the code is fine.

• What are the versions of mypy and Python you are using?
  mypy 0.770
  python 3.7.6

• Do you see the same issue after installing mypy from Git master?
  I'm trying to avoid dealing with that!

• What are the mypy flags you are using? (For example --strict-optional)
  None

[sebastian-philipp]

I think #8993 and #8996 are duplicates.

from abc import ABC, abstractmethod

class Base(ABC):
    @property
    @classmethod
    @abstractmethod
    def CONSTANT(self) -> int:
        pass

    OTHER_CONSTANT = 42

class Derived(Base):
    CONSTANT = 42

reveal_type(Base.CONSTANT)  # file.py:15: note: Revealed type is 'def () -> builtins.int'
reveal_type(Base.OTHER_CONSTANT)   # file.py:16: note: Revealed type is 'builtins.int'

As CONSTANT is an (abstract) class property, it should have the same type as OTHER_CONSTANT. I think this causes both issues.

[JannKleen]

I would like to add that this also seems to happen without the @classmethod.

import abc
from typing import Iterable


class AClass:
    class Meta:
        __metaclass__ = abc.ABCMeta

        @property
        @abc.abstractmethod
        def a_property(self) -> Iterable[str]:
            pass

    def something(self) -> None:
        for item in self.Meta.a_property:
            print(item)

reveal_type(AClass.Meta.a_property)

test.py:15: error: "Callable[[Meta], Iterable[str]]" has no attribute "__iter__" (not iterable)
test.py:18: note: Revealed type is 'def (self: test.AClass.Meta) -> typing.Iterable[builtins.str]'

[alkasm]

Here's an easy workaround for some use-cases:

from abc import ABC


class Base(ABC):

    foo: str

    def __init_subclass__(cls):
        if not hasattr(cls, "foo"):
            raise NotImplementedError(f"{cls} must implement class attribute 'foo'")


class Derived(Base):
    foo = "bar"

Base.foo, Derived.foo, Base().foo, Derived().foo all have the same type, any immediate subclass of Base must implement the attribute, which is checked at class definition time.

This is slightly different than what @abstractmethod does, which won't error at class definition time, only when an instance is created. This allows for intermediary or mixin subclasses which only implement some subset of the required abstract properties to be defined, as long as no concrete instances are created until you have a class which implements all of them. Still, it may be good enough in some cases!

[mdczaplicki]

Any update here? Still an issue.