How to use ParamSpec

[charmoniumQ]

I'm trying to use ParamSpec (PEP 0612). Type checking from type_extensions import ParamSpec works with pyright (yay!), but causes my code to fail at runtime since Python can't import ParamSpec yet. Minimal working example:

from typing import Generic, TypeVar, Callable
from typing_extensions import ParamSpec

Input = ParamSpec("Input")
Output = TypeVar("Output")
class Wrapper(Generic[Input, Output]):
    def __init__(self, func: Callable[Input, Output]) -> None:
        self.func = func
    def __call__(self, *args: Input.args, **kwargs: Input.kwargs) -> Output:
        print(f"Calling {self.func} with {args} and {kwargs}")
        return self.func(*args, **kwargs)

# Traceback (most recent call last):
#   File "/home/grayson5/Downloads/test.py", line 4, in <module>
#     from typing_extensions import ParamSpec
# ImportError: cannot import name 'ParamSpec' from 'typing_extensions'

A prior issue said that to make this work at runtime, one can "stub" the ParamSpec class, as follows. Again, this typechecks perfectly but fails at runtime since Generic checks that its parameters are types.

from typing import TYPE_CHECKING, Generic, TypeVar, Callable, Any

if TYPE_CHECKING:
    from typing_extensions import ParamSpec
else:
    class ParamSpec:
        def __init__(self, name: str): ...
        args: Any = ...
        kwargs: Any = ...

Input = ParamSpec("Input")
Output = TypeVar("Output")
class Wrapper(Generic[Input, Output]):
    def __init__(self, func: Callable[Input, Output]) -> None:
        self.func = func
    def __call__(self, *args: Input.args, **kwargs: Input.kwargs) -> Output:
        print(f"Calling {self.func} with {args} and {kwargs}")
        return self.func(*args, **kwargs)
        
# Traceback (most recent call last):
#   File "/home/grayson5/Downloads/test.py", line 13, in <module>
#     class Wrapper(Generic[Input, Output]):
#     <snip>
# TypeError: Parameters to generic types must be types. Got <__main__.ParamSpec object at 0x7fa715b466d0>.

So how do I use/stub ParamSpec at typecheck-time in a way that won't break at runtime?

[erictraut]

PEP 612 support (including support for ParamSpec and Concatenate) have been added to the typing_extensions library, but a new version of typing_extensions has not yet been published to pypi. See this issue for details.

Here are a couple of alternative suggestions:

1. You could wait until the new typing_extensions library is published and upgrade to it. Feel free to file a request in that repo to ask the maintainers to publish sooner rather than later. :)
2. If you want a solution sooner, here's a variation on your code that should work at runtime.

from __future__ import annotations
from typing import TYPE_CHECKING, Generic, TypeVar, Callable, Any

if TYPE_CHECKING:
    from typing_extensions import ParamSpec
    Input = ParamSpec("Input")
else:
    Input = TypeVar("Input")
Output = TypeVar("Output")

[erictraut]

Did you include the first line (from __future__ import annotations)? That tells the Python interpreter not to evaluate type annotations. (This is the default behavior in Python 3.10, but for older versions of Python it evaluates type annotations.)

[charmoniumQ]

Doi. I knew I was missing something.

Thank you @erictraut.

[charmoniumQ]

One more problem. This doesn't work with cast; Callable has the same complaint about args must be a list. Is there a backwards compatible way to make use this feature?

cast(Callable[Input, Output], thing)

[charmoniumQ]

I think I can make it work by replacing the cast with # type: ignore, although this does compromise static typechecking a litle.

I know you were curious to see use-cases for # type: ignore on this thread. I currently believe this usage is the best option until typing_extensions updates.

[erictraut]

Any time you use cast, you are already compromising static type checking. I try to avoid cast if at all possible.

And you know what I think about # type: ignore based on my comments in that other thread. :)

You can enclose the type expression (the one passed as the first argument to cast) in quotes, and type checkers will still interpret it as a type.

a: str = "hi"
b = cast("int", a)
reveal_type(b) # int