ParamSpec + Generics doesn't work

[klen]

Bug Report

Mypy doesn't process ParamSpec correctly.

To Reproduce

from __future__ import annotations

from collections.abc import Callable
from typing import Any, Generic, ParamSpec, TypeVar

P = ParamSpec("P")
TVFn = TypeVar("TVFn", bound=Callable[..., Any])


class Example(Generic[TVFn]):
    def __init__(self, fn: TVFn):
        self.fn = fn

    def __call__(self: Example[Callable[P, Any]], *args: P.args, **kwargs: P.kwargs):
        ...


def test_fn(a: int, b: str) -> None:
    ...


example = Example(test_fn)
example()  # mypy doesn't show an error for this call
example(1, "b") # mypy show errors for this call

Expected Behavior

example()  # show missing arguments here
example(1, "b")  # pass here

Actual Behavior

Mypy output

paramspec.py:24: error: Argument 1 to "__call__" of "Example" has incompatible type "int"; expected <nothing>  [arg-type]
paramspec.py:24: error: Argument 2 to "__call__" of "Example" has incompatible type "str"; expected <nothing>  [arg-type]
Found 2 errors in 1 file (checked 1 source file)

Your Environment

• Mypy version used: 1.1.1
• Mypy command-line flags:
• Mypy configuration options from mypy.ini (and other config files):
• Python version used: 3.11.2

BTW: in pyright this code working fine

[erictraut]

Your sample doesn't define the symbol Wrapper. I presume that it's a class. Could you add that class definition?

[klen]

@erictraut sorry, there was a small mistype. I've updated the example.

[erictraut]

I agree this is a bug in mypy, but you're using ParamSpec in an unusual way here. Mypy works fine when you use it in a more typical manner.

class Example(Generic[P]):
    def __init__(self, fn: Callable[P, Any]):
        self.fn = fn

    def __call__(self, *args: P.args, **kwargs: P.kwargs):
        ...

[klen]

@erictraut Real examples are more complex and I need whole callable object as TypeVar for the Generic. But you gave me some ideas for further research. Thank you! 🙏

[erictraut]

You probably already figured this out, but if you need the whole callable, you can also capture the return type in the constructor.

P = ParamSpec("P")
R = TypeVar("R")

class Example(Generic[P, R]):
    def __init__(self, fn: Callable[P, R]):
        self.fn = fn

    def __call__(self, *args: P.args, **kwargs: P.kwargs) -> R:
        ...

One situation where this approach won't work (and your original example will) is if the captured function is overloaded.

[hauntsaninja]

@klen is the project you were running into this on open source?