Derived class type error on Callable

[gwww]

I have searched through these discussions and issues and have not found the answer to the following.

I receive this error on line 25 below (error line marked with comment):

Argument of type "(instance: Derived, some_dict: dict[str, Any]) -> None" cannot be assigned to parameter "callback" of type "(Base, dict[str, Any]) -> None" in function "add_callback"
     Type "(instance: Derived, some_dict: dict[str, Any]) -> None" cannot be assigned to type "(Base, dict[str, Any]) -> None"
       Parameter 1: type "Base" cannot be assigned to type "Derived"
         "Base" is incompatible with "Derived"

On this code:

from __future__ import annotations
from collections.abc import Callable
from typing import Any, TypeVar

B = TypeVar("B", bound="Base")

class Base:
    def __init__(self) -> None:
        self._callbacks: list[Callable[[Base, dict[str, Any]], None]] = []

    def add_callback(self, callback: Callable[[Base, dict[str, Any]], None]) -> None:
        self._callbacks.append(callback)

    def call_callbacks(self) -> None:
        for callback in self._callbacks:
            callback(self, {"foo": 1})

class Derived(Base):
    def __init__(self):
        super().__init__()

class Test:
    def __init__(self) -> None:
        d = Derived()
        d.add_callback(self.class_call_me) # <--- error on this line
        d.call_callbacks()

    def class_call_me(self, instance: Derived, some_dict: dict[str, Any]) -> None:
        print(instance, some_dict)

t = Test()

Note the unused TypeVar in the above. When I try to use B instead of Base in the Callable typedef I get this error:

Type variable "B" has no meaning in this context

I have tried multiple variations of TypeVar and Type, and probably a few others I can't remember at the moment. The above code runs and produces the expected result.

Any suggestions would be gratefully received!

[erictraut]

This is a great use case for the new Self type introduced in PEP 673.

from typing_extensions import Self

class Base:
    def __init__(self) -> None:
        self._callbacks: list[Callable[[Self, dict[str, Any]], None]] = []

    def add_callback(self, callback: Callable[[Self, dict[str, Any]], None]) -> None:
        self._callbacks.append(callback)

If you don't want to depend on the Self type, you could use a bound TypeVar, like the B that you defined above. However, you need to use it within a class or a function so it has an associated scope.

class Base:
    def __init__(self: B) -> None:
        self._callbacks: list[Callable[[B, dict[str, Any]], None]] = []

    def add_callback(self: B, callback: Callable[[B, dict[str, Any]], None]) -> None:
        self._callbacks.append(callback)

This approach generates a warning that B appears only once in the __init__ signature, which is typically a misuse of a TypeVar.

Another solution is to avoid all generics and change the class_call_me method to accept a Base parameter instead of Derived.

    def class_call_me(self, instance: Base, some_dict: dict[str, Any]) -> None:
        assert isinstance(instance, Derived)
        print(instance, some_dict)

[gwww]

Thank you!

For others reading this thread...

With the first approach mypy generates the error Variable "typing_extensions.Self" is not valid as a type. Using mypy 0.942 and typing_extensions 4.1.1 (both are latest).

Approach two works, with the warnings you said.

Approach three, my code would have to cast instance to the thing I actually using. So to access an attribute on Derived the code would be something such as:

def class_call_me(self, instance: Base, some_dict: dict[str, Any]) -> None:
    derived_instance = cast(Derived, instance)
    derived_instance.some_attr ...

[erictraut]

For the third approach, I recommend using an assert rather than a cast (as shown in my sample above). Casts are fragile and provide no runtime validation.

[gwww]

Would it not have to be an assert to runtime validate and a cast to access the attributes on Derived without errors?

[erictraut]

Pyright (and other type checkers) apply type narrowing with an assert, so the type of instance is narrowed from Base to Derived after the assert statement. That means no explicit cast is needed.