Proper way to type hint decorator modifying passed arguments

[vient]

Consider following code

from typing import Callable, ParamSpec, TypeVar

_P = ParamSpec('_P')
_R = TypeVar('_R')
_T = TypeVar('_T')

def opaque(x: _T) -> _T:
    ...

def test(f: Callable[_P, _R]) -> Callable[_P, _R]:
    def wrapper(*args: _P.args, **kwargs: _P.kwargs) -> _R:
        return f(*map(opaque, args), **kwargs)  # Arguments for ParamSpec "_P@test" are missing

    return wrapper

Innermost return f(...) reports error. Since opaque returns the same type it was passed, I expected pyright to be happy with this code. What am I doing incorrectly here?

[erictraut]

Moving to discussion since this isn't a bug report.

[erictraut]

I'm not able to repro any error with the latest version. Perhaps you're using an older version? Please try updating to the latest (1.1.392).

Here's a link to the code in the pyright playground.

[vient]

Right now pyright-play does not work for me. If it works for you, please check the link from the post, it should use latest version.

[vient]

Works now, your link reports error too.

[erictraut]

Ah yes, it appears that Azure is struggling this afternoon. I'm able to repro the error now.

The problem is that your code is not passing the unmodified *args arguments to the callee. It's modifying them before passing them along. That won't work for a ParamSpec. Not surprisingly, mypy generates the same error here, which is required by the typing spec.

You may need to use # pyright: ignore or # type: ignore in this case.

[vient]

Oh, okay, I thought there may be a way to say "types are the same", like typing.cast(_P.args, tuple(map(opaque, args))) but correct. Thanks!

[vient]

Guess this is because map(opaque, args) mixes types, in a sense that tuple(map(opaque, [1, 'a'])) istuple[int|str, ...] from pyright's perspective, while I expected it to infer tuple[int, str] in this case.

May it be possible to write type hints indicating that a function returns tuple consisting of the types matching argument types? Something like this:

def fn(*args: ???) -> ???:
  return tuple(*args)

reveal_type(fn(1, 'a'))  # tuple[int, str]