How should I type-hint a generic class method that calls another class method to construct an instance of the class?

Question

I'm trying to figure out the type hinting for a couple of abstract classes that I want to use as base classes for classes have a create function. Specifically, this is for deserialization typing.

My simple example looks like this

from abc import ABC, abstractmethod
from typing import Type, TypeVar


T = TypeVar("T", bound="A")


class A(ABC):
    @classmethod
    @abstractmethod
    def create(cls: Type[T]) -> T:
        pass

class B(A, ABC):
    @classmethod
    @abstractmethod
    def create_b(cls: Type[T]) -> T:
        pass

    @classmethod
    def create(cls) -> T:
        return cls.create_b()

When I run Mypy against this I get

error: Incompatible return value type (got "B", expected "T")

I'm confused by this because B inherits from A, and I thought that T more or less represented "any A".

I can change the penultimate line to

    def create(cls: Type[T]) -> T:

but then I get

error: "Type[T]" has no attribute "create_b"

What should I be doing to get mypy to pass?

Answer 1

Since create is a class method, the argument cls has type Type[B]. This means that the T as specified for argument and return types in create_b will be resolved to B and therefore the expression cls.create_b() has type B. This results in the error you get.

The confusing part here is probably that since B is a subtype of A and T is bound to A, one might expect that it should be possible to return B in B.create(). The problem is however, that T will be resolved when B.create() is being used in some context and not earlier. In your example, you implicitly already enforce T to be B, which can lead to type errors.

As an example, let's say we create the following class and function.

class C(A):
    pass


def foo(x: C):
    pass

We can now use B.create() as an argument of foo:

foo(B.create())

The type checker won't complain here, because it resolves T (the generic return type of create as C, which is perfectly fine, since T is bound by A and C is a subtype of A.

Revisiting the function definition of B.create(), we can now see that we actually must return the abstract type T and not some permissible realization of T, such as B (or even A).

TL;DR

You can fix your error by changing the return type of B.create():

@classmethod
def create(cls) -> "B":
    return cls.create_b()