In Mypy and Pyright, generic __call__ method of non-generic class does not unify with Callable that doesn't use Any. Should it?

[mwchase]

What I'm trying to do:

In a code base I'm working on, there are several places where I'm using a Mapping subclass in a non-standard way, and I'm implementing the typing related to it using a protocol. Basically, there is some relation between the types of the key and the value, but instead of applying at the mapping level, it's between each key-value pair.

I'm representing these using non-generic protocols that have methods something like:

    def __getitem__(self, __key: Label[T]) -> T:
        ...

or

    def __getitem__(self, __key: Label[Tuple[T, ...]]) -> T:
        ...

So, you could index the first with a Label[str] to get a str, or, with the same object, a Label[int] to get an int.

(The values get in there using similarly-written set() methods; the actual runtime type is a PMap from pyrsistent.)

(Label is an internal type that's right now basically like a generic newtype around object.)

Anyway, because I need several different relationships between key and value in different contexts, I currently have a bunch of protocol classes that express very similar boilerplate. It would be nice to be able to abstract over this somehow, so I just need to define the wrapper once, and can then just specialize it somehow.
After seeing someone have a similar issue in the gitter channel, I came up with something that would solve the problem, if it worked. With the samples above, it would look something like this:

TCallable = TypeVar("TCallable", bound=Callable[..., Any], covariant=True)

class MyMap(Protocol[TCallable]):
    def __getitem__(self: Callable[[K], V], __k: K) -> V:
        ...

# From a code-working standpoint, it doesn't matter if this is a Protocol, but I think it makes more sense
class DirectLabel(Protocol):
    def __call__(self, __k: Label[T]) -> T:
        ...

class TupleElementLabel(Protocol):
    def __call__(self, __k: Label[Tuple[T, ...]]) -> T:
        ...

DirectMap = MyMap[DirectLabel]
TupleElementMap = MyMap[TupleElementLabel]

I wrote that all up without testing it, but if you substitute in the obvious values for the stuff I left implicit, that code all passes type-checking if I didn't make a mistake.

My question, which I already asked in gitter but I didn't get many responses, is whether using those protocols down there should work, from a typing perspective.
When I tried out similar code in Mypy and Pyright, when I get as far as something like direct_map[int_label], it didn't unify the argument to __getitem__ with the argument to the protocol's __call__ method, with the result that there's a type error because of something like, Label[int] isn't Label[T], and the return value that comes back is T`-1.

(Precise details may be off because I'm trying to bridge the gap between the simplified code I tried, and my actual use case, but I don't expect my use case to work if the simplified code doesn't.)

Ultimately, what I'm asking is, is this a bug (presumably against type checkers), or a feature request?

EDIT: full, simplified example

from typing import Any, Callable, Protocol, TypeVar

T = TypeVar("T")
TCallable = TypeVar("TCallable", bound=Callable[..., Any], covariant=True)  # covariant seems to be required
K = TypeVar("K")
V = TypeVar("V")

class Id(Protocol):
    def __call__(self, __t: T) -> T:
        ...

id_var: Id
callable_var: Callable[[int], int]

callable_var = id_var

class TMap(Protocol[TCallable]):
    def __getitem__(self: TMap[Callable[[K], V]], __key: K) -> V:
        ...

t_map: TMap[Id]

reveal_type(t_map[1])  # want 'Revealed type is "builtins.int"', get 'Revealed type is "T`-1"'
reveal_type(t_map["1"])  # want 'Revealed type is "builtins.str"', get 'Revealed type is "T`-1"'
# Those types would probably actually end up as literals. Assume a more opaque expression for general usage.
# Both lines error with 'Invalid index type "[type]" for "TMap[Id]"; expected type "T"'

[erictraut]

Could you provide a minimal, complete code sample that demonstrates what you're seeing and what you would expect to see?

[Akuli]

The question now has a minimal and complete example. (We don't get notifications for edits)

[erictraut]

Function-scoped type variables are "solved" by a type checker in the context of a call expression that invokes that function. In your example, the Id.__call__ method has function-scoped type variables, but it is never invoked via a call expression (either implicitly or explicitly), so there is no opportunity to "solve" for T.

My recommendation in this case is to make Id a generic class and use explicit specialization.

class Id(Protocol[T]):
    def __call__(self, __t: T) -> T:
        ...

IntId = Id[int]

class TMap(Protocol[TCallable]):
    def __getitem__(self: TMap[Callable[[K], V]], __key: K) -> V:
        ...

def func2(t_map: TMap[IntId]):
    reveal_type(t_map[1])  # Revealed type is "int"
    reveal_type(t_map["1"])  # Error: Literal["1"] cannot be assigned to type "int"

This type checks correctly in pyright and mypy.