[case testBasicParamSpec]

from typing_extensions import ParamSpec

P = ParamSpec('P')

[builtins fixtures/tuple.pyi]

[case testInvalidParamSpecDefinitions]

from typing import ParamSpec

P1 = ParamSpec("P1", covariant=True) # E: The variance and bound arguments to ParamSpec do not have defined semantics yet

P2 = ParamSpec("P2", contravariant=True) # E: The variance and bound arguments to ParamSpec do not have defined semantics yet

P3 = ParamSpec("P3", bound=int) # E: The variance and bound arguments to ParamSpec do not have defined semantics yet

P4 = ParamSpec("P4", int, str) # E: Too many positional arguments for "ParamSpec"

P5 = ParamSpec("P5", covariant=True, bound=int) # E: The variance and bound arguments to ParamSpec do not have defined semantics yet

[builtins fixtures/paramspec.pyi]

[case testParamSpecLocations]

from typing import Any, Callable, List, Type

from typing_extensions import ParamSpec, Concatenate

P = ParamSpec('P')

x: P # E: ParamSpec "P" is unbound

def foo1(x: Callable[P, int]) -> Callable[P, str]: ...

def foo2(x: P) -> P: ... # E: Invalid location for ParamSpec "P" \

# N: You can use ParamSpec as the first argument to Callable, e.g., "Callable[P, int]"

def foo3(x: Concatenate[int, P]) -> int: ... # E: Invalid location for Concatenate \

# N: You can use Concatenate as the first argument to Callable

def foo4(x: List[P]) -> None: ... # E: Invalid location for ParamSpec "P" \

# N: You can use ParamSpec as the first argument to Callable, e.g., "Callable[P, int]"

def foo5(x: Callable[[int, str], P]) -> None: ... # E: Invalid location for ParamSpec "P" \

# N: You can use ParamSpec as the first argument to Callable, e.g., "Callable[P, int]"

def foo6(x: Callable[[P], int]) -> None: ... # E: Invalid location for ParamSpec "P" \

# N: You can use ParamSpec as the first argument to Callable, e.g., "Callable[P, int]"

def foo7(

*args: P.args, **kwargs: P.kwargs # E: ParamSpec "P" is unbound

) -> Callable[[Callable[P, T]], Type[T]]:

...

def wrapper(f: Callable[P, int]) -> None:

def inner(*args: P.args, **kwargs: P.kwargs) -> None: ... # OK

def extra_args_left(x: int, *args: P.args, **kwargs: P.kwargs) -> None: ... # OK

def extra_args_between(*args: P.args, x: int, **kwargs: P.kwargs) -> None: ... # E: Arguments not allowed after ParamSpec.args

def swapped(*args: P.kwargs, **kwargs: P.args) -> None: ... # E: Use "P.args" for variadic "*" parameter \

# E: Use "P.kwargs" for variadic "**" parameter

def bad_kwargs(*args: P.args, **kwargs: P.args) -> None: ... # E: Use "P.kwargs" for variadic "**" parameter

def bad_args(*args: P.kwargs, **kwargs: P.kwargs) -> None: ... # E: Use "P.args" for variadic "*" parameter

def misplaced(x: P.args) -> None: ... # E: ParamSpec components are not allowed here

def bad_kwargs_any(*args: P.args, **kwargs: Any) -> None: ... # E: ParamSpec must have "*args" typed as "P.args" and "**kwargs" typed as "P.kwargs"

[builtins fixtures/paramspec.pyi]

[case testParamSpecImports]

import lib

from lib import Base

class C(Base[[int]]):

def test(self, x: int): ...

class D(lib.Base[[int]]):

def test(self, x: int): ...

class E(lib.Base[...]): ...

reveal_type(E().test) # N: Revealed type is "def (*Any, **Any)"

[file lib.py]

from typing import Generic

from typing_extensions import ParamSpec

P = ParamSpec("P")

class Base(Generic[P]):

def test(self, *args: P.args, **kwargs: P.kwargs) -> None:

...

[builtins fixtures/paramspec.pyi]

[case testParamSpecEllipsisInAliases]

from typing import Any, Callable, Generic, TypeVar

from typing_extensions import ParamSpec

P = ParamSpec('P')

R = TypeVar('R')

Alias = Callable[P, R]

class B(Generic[P]): ...

Other = B[P]

T = TypeVar('T', bound=Alias[..., Any])

Alias[..., Any] # E: Type application is only supported for generic classes

B[...]

Other[...]

[builtins fixtures/paramspec.pyi]

[case testParamSpecEllipsisInConcatenate]

from typing import Any, Callable, Generic, TypeVar

from typing_extensions import ParamSpec, Concatenate

P = ParamSpec('P')

R = TypeVar('R')

Alias = Callable[P, R]

IntFun = Callable[Concatenate[int, ...], None]

f: IntFun

reveal_type(f) # N: Revealed type is "def (builtins.int, *Any, **Any)"

g: Callable[Concatenate[int, ...], None]

reveal_type(g) # N: Revealed type is "def (builtins.int, *Any, **Any)"

class B(Generic[P]):

def test(self, *args: P.args, **kwargs: P.kwargs) -> None:

...

x: B[Concatenate[int, ...]]

reveal_type(x.test) # N: Revealed type is "def (builtins.int, *Any, **Any)"

Bad = Callable[Concatenate[int, [int, str]], None] # E: The last parameter to Concatenate needs to be a ParamSpec \

# E: Bracketed expression "[...]" is not valid as a type

def bad(fn: Callable[Concatenate[P, int], None]): # E: The last parameter to Concatenate needs to be a ParamSpec

...

[builtins fixtures/paramspec.pyi]

[case testParamSpecContextManagerLike]

from typing import Callable, List, Iterator, TypeVar

from typing_extensions import ParamSpec

P = ParamSpec('P')

T = TypeVar('T')

def tmpcontextmanagerlike(x: Callable[P, Iterator[T]]) -> Callable[P, List[T]]: ...

@tmpcontextmanagerlike

def whatever(x: int) -> Iterator[int]:

yield x

reveal_type(whatever) # N: Revealed type is "def (x: builtins.int) -> builtins.list[builtins.int]"

reveal_type(whatever(217)) # N: Revealed type is "builtins.list[builtins.int]"

[builtins fixtures/paramspec.pyi]

[case testInvalidParamSpecType]

from typing import ParamSpec

P = ParamSpec("P")

class MyFunction(P): # E: Invalid base class "P"

...

[case testParamSpecRevealType]

from typing import Callable

from typing_extensions import ParamSpec

P = ParamSpec('P')

def f(x: Callable[P, int]) -> None: ...

reveal_type(f) # N: Revealed type is "def [P] (x: def (*P.args, **P.kwargs) -> builtins.int)"

[builtins fixtures/paramspec.pyi]

[case testParamSpecSimpleFunction]

from typing import Callable, TypeVar

from typing_extensions import ParamSpec

P = ParamSpec('P')

def changes_return_type_to_str(x: Callable[P, int]) -> Callable[P, str]: ...

def returns_int(a: str, b: bool) -> int: ...

reveal_type(changes_return_type_to_str(returns_int)) # N: Revealed type is "def (a: builtins.str, b: builtins.bool) -> builtins.str"

[builtins fixtures/paramspec.pyi]

[case testParamSpecSimpleClass]

from typing import Callable, TypeVar, Generic

from typing_extensions import ParamSpec

P = ParamSpec('P')

class C(Generic[P]):

def __init__(self, x: Callable[P, None]) -> None: ...

def m(self, *args: P.args, **kwargs: P.kwargs) -> int:

return 1

def f(x: int, y: str) -> None: ...

reveal_type(C(f)) # N: Revealed type is "__main__.C[[x: builtins.int, y: builtins.str]]"

reveal_type(C(f).m) # N: Revealed type is "def (x: builtins.int, y: builtins.str) -> builtins.int"

[builtins fixtures/dict.pyi]

[case testParamSpecClassWithPrefixArgument]

from typing import Callable, TypeVar, Generic

from typing_extensions import ParamSpec

P = ParamSpec('P')

class C(Generic[P]):

def __init__(self, x: Callable[P, None]) -> None: ...

def m(self, a: str, *args: P.args, **kwargs: P.kwargs) -> int:

return 1

def f(x: int, y: str) -> None: ...

reveal_type(C(f).m) # N: Revealed type is "def (a: builtins.str, x: builtins.int, y: builtins.str) -> builtins.int"

reveal_type(C(f).m('', 1, '')) # N: Revealed type is "builtins.int"

[builtins fixtures/dict.pyi]

[case testParamSpecDecorator]

from typing import Callable, TypeVar, Generic

from typing_extensions import ParamSpec

P = ParamSpec('P')

R = TypeVar('R')

class W(Generic[P, R]):

f: Callable[P, R]

x: int

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

reveal_type(self.f(*args, **kwargs)) # N: Revealed type is "R`2"

return self.f(*args, **kwargs)

def dec() -> Callable[[Callable[P, R]], W[P, R]]:

pass

@dec()

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

reveal_type(f) # N: Revealed type is "__main__.W[[a: builtins.int, b: builtins.str], None]"

reveal_type(f(1, '')) # N: Revealed type is "None"

reveal_type(f.x) # N: Revealed type is "builtins.int"

## TODO: How should this work?

#

# class C:

# @dec()

# def m(self, x: int) -> str: ...

#

# reveal_type(C().m(x=1))

[builtins fixtures/dict.pyi]

[case testParamSpecFunction]

from typing import Callable, TypeVar

from typing_extensions import ParamSpec

P = ParamSpec('P')

R = TypeVar('R')

def f(x: Callable[P, R], *args: P.args, **kwargs: P.kwargs) -> R:

return x(*args, **kwargs)

def g(x: int, y: str) -> None: ...

reveal_type(f(g, 1, y='x')) # N: Revealed type is "None"

f(g, 'x', y='x') # E: Argument 2 to "f" has incompatible type "str"; expected "int"

f(g, 1, y=1) # E: Argument "y" to "f" has incompatible type "int"; expected "str"

f(g) # E: Missing positional arguments "x", "y" in call to "f"

[builtins fixtures/dict.pyi]

[case testParamSpecSpecialCase]

from typing import Callable, TypeVar

from typing_extensions import ParamSpec

P = ParamSpec('P')

T = TypeVar('T')

def register(func: Callable[P, T], *args: P.args, **kwargs: P.kwargs) -> Callable[P, T]: ...

def f(x: int, y: str, z: int, a: str) -> None: ...

x = register(f, 1, '', 1, '')

[builtins fixtures/dict.pyi]

[case testParamSpecInferredFromAny]

from typing import Callable, Any

from typing_extensions import ParamSpec

P = ParamSpec('P')

def f(x: Callable[P, int]) -> Callable[P, str]: ...

g: Any

reveal_type(f(g)) # N: Revealed type is "def (*Any, **Any) -> builtins.str"

f(g)(1, 3, x=1, y=2)

[builtins fixtures/paramspec.pyi]

[case testParamSpecDecoratorImplementation]

from typing import Callable, Any, TypeVar, List

from typing_extensions import ParamSpec

P = ParamSpec('P')

T = TypeVar('T')

def dec(f: Callable[P, T]) -> Callable[P, List[T]]:

def wrapper(*args: P.args, **kwargs: P.kwargs) -> List[T]:

return [f(*args, **kwargs)]

return wrapper

@dec

def g(x: int, y: str = '') -> int: ...

reveal_type(g) # N: Revealed type is "def (x: builtins.int, y: builtins.str =) -> builtins.list[builtins.int]"

[builtins fixtures/dict.pyi]

[case testParamSpecArgsAndKwargsTypes]

from typing import Callable, TypeVar, Generic

from typing_extensions import ParamSpec

P = ParamSpec('P')

class C(Generic[P]):

def __init__(self, x: Callable[P, None]) -> None: ...

def m(self, *args: P.args, **kwargs: P.kwargs) -> None:

reveal_type(args) # N: Revealed type is "P.args`1"

reveal_type(kwargs) # N: Revealed type is "P.kwargs`1"

[builtins fixtures/dict.pyi]

[case testParamSpecSubtypeChecking1]

from typing import Callable, TypeVar, Generic, Any

from typing_extensions import ParamSpec

P = ParamSpec('P')

class C(Generic[P]):

def __init__(self, x: Callable[P, None]) -> None: ...

def m(self, *args: P.args, **kwargs: P.kwargs) -> None:

args = args

kwargs = kwargs

o: object

o = args

o = kwargs

o2: object

args = o2 # E: Incompatible types in assignment (expression has type "object", variable has type "P.args")

kwargs = o2 # E: Incompatible types in assignment (expression has type "object", variable has type "P.kwargs")

a: Any

a = args

a = kwargs

args = kwargs # E: Incompatible types in assignment (expression has type "P.kwargs", variable has type "P.args")

kwargs = args # E: Incompatible types in assignment (expression has type "P.args", variable has type "P.kwargs")

a1: Any

args = a1

kwargs = a1

[builtins fixtures/dict.pyi]

[case testParamSpecSubtypeChecking2]

from typing import Callable, Generic

from typing_extensions import ParamSpec

P = ParamSpec('P')

P2 = ParamSpec('P2')

class C(Generic[P]):

pass

def f(c1: C[P], c2: C[P2]) -> None:

c1 = c1

c2 = c2

c1 = c2 # E: Incompatible types in assignment (expression has type "C[P2]", variable has type "C[P]")

c2 = c1 # E: Incompatible types in assignment (expression has type "C[P]", variable has type "C[P2]")

def g(f: Callable[P, None], g: Callable[P2, None]) -> None:

f = f

g = g

f = g # E: Incompatible types in assignment (expression has type "Callable[P2, None]", variable has type "Callable[P, None]")

g = f # E: Incompatible types in assignment (expression has type "Callable[P, None]", variable has type "Callable[P2, None]")

[builtins fixtures/dict.pyi]

[case testParamSpecJoin]

from typing import Callable, Generic, TypeVar

from typing_extensions import ParamSpec

P = ParamSpec('P')

P2 = ParamSpec('P2')

P3 = ParamSpec('P3')

T = TypeVar('T')

def join(x: T, y: T) -> T: ...

class C(Generic[P, P2]):

def m(self, f: Callable[P, None], g: Callable[P2, None]) -> None:

reveal_type(join(f, f)) # N: Revealed type is "def (*P.args, **P.kwargs)"

reveal_type(join(f, g)) # N: Revealed type is "builtins.function"

def m2(self, *args: P.args, **kwargs: P.kwargs) -> None:

reveal_type(join(args, args)) # N: Revealed type is "P.args`1"

reveal_type(join(kwargs, kwargs)) # N: Revealed type is "P.kwargs`1"

reveal_type(join(args, kwargs)) # N: Revealed type is "builtins.object"

def f(*args2: P2.args, **kwargs2: P2.kwargs) -> None:

reveal_type(join(args, args2)) # N: Revealed type is "builtins.object"

reveal_type(join(kwargs, kwargs2)) # N: Revealed type is "builtins.object"

def m3(self, c: C[P, P3]) -> None:

reveal_type(join(c, c)) # N: Revealed type is "__main__.C[P`1, P3`-1]"

reveal_type(join(self, c)) # N: Revealed type is "builtins.object"

[builtins fixtures/dict.pyi]

[case testParamSpecClassWithAny]

from typing import Callable, Generic, Any

from typing_extensions import ParamSpec

P = ParamSpec('P')

class C(Generic[P]):

def __init__(self, x: Callable[P, None]) -> None: ...

def m(self, *args: P.args, **kwargs: P.kwargs) -> int:

return 1

c: C[Any]

reveal_type(c) # N: Revealed type is "__main__.C[Any]"

reveal_type(c.m) # N: Revealed type is "def (*args: Any, **kwargs: Any) -> builtins.int"

c.m(4, 6, y='x')

c = c

def f() -> None: pass

c2 = C(f)

c2 = c

c3 = C(f)

c = c3

[builtins fixtures/dict.pyi]

[case testParamSpecInferredFromLambda]

from typing import Callable, TypeVar

from typing_extensions import ParamSpec

P = ParamSpec('P')

T = TypeVar('T')

# Similar to atexit.register

def register(f: Callable[P, T], *args: P.args, **kwargs: P.kwargs) -> Callable[P, T]: ...

def f(x: int) -> None: pass

def g(x: int, y: str) -> None: pass

reveal_type(register(lambda: f(1))) # N: Revealed type is "def ()"

reveal_type(register(lambda x: f(x), x=1)) # N: Revealed type is "def (x: Literal[1]?)"

register(lambda x: f(x)) # E: Cannot infer type of lambda \

# E: Argument 1 to "register" has incompatible type "Callable[[Any], None]"; expected "Callable[[], None]"

register(lambda x: f(x), y=1) # E: Argument 1 to "register" has incompatible type "def (x: int) -> None"; expected "def (y: int) -> None"

reveal_type(register(lambda x: f(x), 1)) # N: Revealed type is "def (Literal[1]?)"

reveal_type(register(lambda x, y: g(x, y), 1, "a")) # N: Revealed type is "def (Literal[1]?, Literal['a']?)"

reveal_type(register(lambda x, y: g(x, y), 1, y="a")) # N: Revealed type is "def (Literal[1]?, y: Literal['a']?)"

[builtins fixtures/dict.pyi]

[case testParamSpecInvalidCalls]

from typing import Callable, Generic

from typing_extensions import ParamSpec

P = ParamSpec('P')

P2 = ParamSpec('P2')

class C(Generic[P, P2]):

def m1(self, *args: P.args, **kwargs: P.kwargs) -> None:

self.m1(*args, **kwargs)

self.m2(*args, **kwargs) # E: Argument 1 to "m2" of "C" has incompatible type "*P.args"; expected "P2.args" \

# E: Argument 2 to "m2" of "C" has incompatible type "**P.kwargs"; expected "P2.kwargs"

self.m1(*kwargs, **args) # E: Argument 1 to "m1" of "C" has incompatible type "*P.kwargs"; expected "P.args" \

# E: Argument 2 to "m1" of "C" has incompatible type "**P.args"; expected "P.kwargs"

self.m3(*args, **kwargs) # E: Argument 1 to "m3" of "C" has incompatible type "*P.args"; expected "int" \

# E: Argument 2 to "m3" of "C" has incompatible type "**P.kwargs"; expected "int"

self.m4(*args, **kwargs) # E: Argument 1 to "m4" of "C" has incompatible type "*P.args"; expected "int" \

# E: Argument 2 to "m4" of "C" has incompatible type "**P.kwargs"; expected "int"

self.m1(*args, **args) # E: Argument 2 to "m1" of "C" has incompatible type "**P.args"; expected "P.kwargs"

self.m1(*kwargs, **kwargs) # E: Argument 1 to "m1" of "C" has incompatible type "*P.kwargs"; expected "P.args"

def m2(self, *args: P2.args, **kwargs: P2.kwargs) -> None:

pass

def m3(self, *args: int, **kwargs: int) -> None:

pass

def m4(self, x: int) -> None:

pass

[builtins fixtures/dict.pyi]

[case testParamSpecOverUnannotatedDecorator]

from typing import Callable, Iterator, TypeVar, ContextManager, Any

from typing_extensions import ParamSpec

from nonexistent import deco2 # type: ignore

T = TypeVar("T")

P = ParamSpec("P")

T_co = TypeVar("T_co", covariant=True)

class CM(ContextManager[T_co]):

def __call__(self, func: T) -> T: ...

def deco1(

func: Callable[P, Iterator[T]]) -> Callable[P, CM[T]]: ...

@deco1

@deco2

def f():

pass

reveal_type(f) # N: Revealed type is "def (*Any, **Any) -> __main__.CM[Any]"

with f() as x:

pass

[builtins fixtures/dict.pyi]

[typing fixtures/typing-full.pyi]

[case testParamSpecLiterals]

from typing_extensions import ParamSpec, TypeAlias

from typing import Generic, TypeVar

P = ParamSpec("P")

T = TypeVar("T")

class Z(Generic[P]): ...

# literals can be applied

n: Z[[int]]

nt1 = Z[[int]]

nt2: TypeAlias = Z[[int]]

unt1: nt1

unt2: nt2

# literals actually keep types

reveal_type(n) # N: Revealed type is "__main__.Z[[builtins.int]]"

reveal_type(unt1) # N: Revealed type is "__main__.Z[[builtins.int]]"

reveal_type(unt2) # N: Revealed type is "__main__.Z[[builtins.int]]"

# passing into a function keeps the type

def fT(a: T) -> T: ...

def fP(a: Z[P]) -> Z[P]: ...

reveal_type(fT(n)) # N: Revealed type is "__main__.Z[[builtins.int]]"

reveal_type(fP(n)) # N: Revealed type is "__main__.Z[[builtins.int]]"

# literals can be in function args and return type

def k(a: Z[[int]]) -> Z[[str]]: ...

# functions work

reveal_type(k(n)) # N: Revealed type is "__main__.Z[[builtins.str]]"

# literals can be matched in arguments

def kb(a: Z[[bytes]]) -> Z[[str]]: ...

reveal_type(kb(n)) # N: Revealed type is "__main__.Z[[builtins.str]]" \

# E: Argument 1 to "kb" has incompatible type "Z[[int]]"; expected "Z[[bytes]]"

n2: Z[bytes]

reveal_type(kb(n2)) # N: Revealed type is "__main__.Z[[builtins.str]]"

[builtins fixtures/tuple.pyi]

[case testParamSpecConcatenateFromPep]

from typing_extensions import ParamSpec, Concatenate

from typing import Callable, TypeVar, Generic

P = ParamSpec("P")

R = TypeVar("R")

# CASE 1

class Request:

...

def with_request(f: Callable[Concatenate[Request, P], R]) -> Callable[P, R]:

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

return f(Request(), *args, **kwargs)

return inner

@with_request

def takes_int_str(request: Request, x: int, y: str) -> int:

# use request

return x + 7

reveal_type(takes_int_str) # N: Revealed type is "def (x: builtins.int, y: builtins.str) -> builtins.int"

takes_int_str(1, "A") # Accepted

takes_int_str("B", 2) # E: Argument 1 to "takes_int_str" has incompatible type "str"; expected "int" \

# E: Argument 2 to "takes_int_str" has incompatible type "int"; expected "str"

# CASE 2

T = TypeVar("T")

P_2 = ParamSpec("P_2")

class X(Generic[T, P]):

f: Callable[P, int]

x: T

def f1(x: X[int, P_2]) -> str: ... # Accepted

def f2(x: X[int, Concatenate[int, P_2]]) -> str: ... # Accepted

def f3(x: X[int, [int, bool]]) -> str: ... # Accepted

# ellipsis only show up here, but I can assume it works like Callable[..., R]

def f4(x: X[int, ...]) -> str: ... # Accepted

def f5(x: X[int, int]) -> str: ... # E: Can only replace ParamSpec with a parameter types list or another ParamSpec, got "int"

# CASE 3

def bar(x: int, *args: bool) -> int: ...

def add(x: Callable[P, int]) -> Callable[Concatenate[str, P], bool]: ...

reveal_type(add(bar)) # N: Revealed type is "def (builtins.str, x: builtins.int, *args: builtins.bool) -> builtins.bool"

def remove(x: Callable[Concatenate[int, P], int]) -> Callable[P, bool]: ...

reveal_type(remove(bar)) # N: Revealed type is "def (*args: builtins.bool) -> builtins.bool"

def transform(

x: Callable[Concatenate[int, P], int]

) -> Callable[Concatenate[str, P], bool]: ...

# In the PEP, "__a" appears. What is that? Autogenerated names? To what spec?

reveal_type(transform(bar)) # N: Revealed type is "def (builtins.str, *args: builtins.bool) -> builtins.bool"

# CASE 4

def expects_int_first(x: Callable[Concatenate[int, P], int]) -> None: ...

@expects_int_first # E: Argument 1 to "expects_int_first" has incompatible type "Callable[[str], int]"; expected "Callable[[int], int]" \

# N: This is likely because "one" has named arguments: "x". Consider marking them positional-only

def one(x: str) -> int: ...

@expects_int_first # E: Argument 1 to "expects_int_first" has incompatible type "def two(*, x: int) -> int"; expected "def (int, /, *, x: int) -> int"

def two(*, x: int) -> int: ...

@expects_int_first # E: Argument 1 to "expects_int_first" has incompatible type "def three(**kwargs: int) -> int"; expected "def (int, /, **kwargs: int) -> int"

def three(**kwargs: int) -> int: ...

@expects_int_first # Accepted

def four(*args: int) -> int: ...

[builtins fixtures/dict.pyi]

[case testParamSpecTwiceSolving]

from typing_extensions import ParamSpec, Concatenate

from typing import Callable, TypeVar

P = ParamSpec("P")

R = TypeVar("R")

def f(one: Callable[Concatenate[int, P], R], two: Callable[Concatenate[str, P], R]) -> Callable[P, R]: ...

a: Callable[[int, bytes], str]

b: Callable[[str, bytes], str]

reveal_type(f(a, b)) # N: Revealed type is "def (builtins.bytes) -> builtins.str"

[builtins fixtures/paramspec.pyi]

[case testParamSpecConcatenateInReturn]

from typing_extensions import ParamSpec, Concatenate

from typing import Callable, Protocol

P = ParamSpec("P")

def f(i: Callable[Concatenate[int, P], str]) -> Callable[Concatenate[int, P], str]: ...

n: Callable[[int, bytes], str]

reveal_type(f(n)) # N: Revealed type is "def (builtins.int, builtins.bytes) -> builtins.str"

[builtins fixtures/paramspec.pyi]

[case testParamSpecConcatenateNamedArgs]

# flags: --extra-checks

# this is one noticeable deviation from PEP but I believe it is for the better

from typing_extensions import ParamSpec, Concatenate

from typing import Callable, TypeVar

P = ParamSpec("P")

R = TypeVar("R")

def f1(c: Callable[P, R]) -> Callable[Concatenate[int, P], R]:

def result(x: int, /, *args: P.args, **kwargs: P.kwargs) -> R: ...

return result # Accepted

def f2(c: Callable[P, R]) -> Callable[Concatenate[int, P], R]:

def result(x: int, *args: P.args, **kwargs: P.kwargs) -> R: ...

return result # Rejected

# reason for rejection:

f2(lambda x: 42)(42, x=42)

[builtins fixtures/paramspec.pyi]

[out]

main:17: error: Incompatible return value type (got "Callable[[Arg(int, 'x'), **P], R]", expected "Callable[[int, **P], R]")

main:17: note: This is likely because "result" has named arguments: "x". Consider marking them positional-only

[case testNonStrictParamSpecConcatenateNamedArgs]

# this is one noticeable deviation from PEP but I believe it is for the better

from typing_extensions import ParamSpec, Concatenate

from typing import Callable, TypeVar

P = ParamSpec("P")

R = TypeVar("R")

def f1(c: Callable[P, R]) -> Callable[Concatenate[int, P], R]:

def result(x: int, /, *args: P.args, **kwargs: P.kwargs) -> R: ...

return result # Accepted

def f2(c: Callable[P, R]) -> Callable[Concatenate[int, P], R]:

def result(x: int, *args: P.args, **kwargs: P.kwargs) -> R: ...

return result # Rejected -> Accepted

# reason for rejection:

f2(lambda x: 42)(42, x=42)

[builtins fixtures/paramspec.pyi]

[case testParamSpecConcatenateWithTypeVar]

from typing_extensions import ParamSpec, Concatenate

from typing import Callable, TypeVar

P = ParamSpec("P")

R = TypeVar("R")

S = TypeVar("S")

def f(c: Callable[Concatenate[S, P], R]) -> Callable[Concatenate[S, P], R]: ...

def a(n: int) -> None: ...

n = f(a)

reveal_type(n) # N: Revealed type is "def (builtins.int)"

reveal_type(n(42)) # N: Revealed type is "None"

[builtins fixtures/paramspec.pyi]

[case testCallablesAsParameters]

# credits to https://github.com/microsoft/pyright/issues/2705

from typing_extensions import ParamSpec, Concatenate

from typing import Generic, Callable, Any

P = ParamSpec("P")

class Foo(Generic[P]):

def __init__(self, func: Callable[P, Any]) -> None: ...

def bar(baz: Foo[Concatenate[int, P]]) -> Foo[P]: ...

def test(a: int, /, b: str) -> str: ...

abc = Foo(test)

reveal_type(abc)

bar(abc)

[builtins fixtures/paramspec.pyi]

[out]

main:14: note: Revealed type is "__main__.Foo[[builtins.int, b: builtins.str]]"

[case testSolveParamSpecWithSelfType]

from typing_extensions import ParamSpec, Concatenate

from typing import Callable, Generic

P = ParamSpec("P")

class Foo(Generic[P]):

def foo(self: 'Foo[P]', other: Callable[P, None]) -> None: ...

n: Foo[[int]]

def f(x: int) -> None: ...

n.foo(f)

[builtins fixtures/paramspec.pyi]

[case testParamSpecLiteralsTypeApplication]

from typing_extensions import ParamSpec

from typing import Generic, Callable

P = ParamSpec("P")

class Z(Generic[P]):

def __init__(self, c: Callable[P, None]) -> None:

...

# it allows valid functions

reveal_type(Z[[int]](lambda x: None)) # N: Revealed type is "__main__.Z[[builtins.int]]"

reveal_type(Z[[]](lambda: None)) # N: Revealed type is "__main__.Z[[]]"

reveal_type(Z[bytes, str](lambda b, s: None)) # N: Revealed type is "__main__.Z[[builtins.bytes, builtins.str]]"

# it disallows invalid functions

def f1(n: str) -> None: ...

def f2(b: bytes, i: int) -> None: ...

Z[[int]](lambda one, two: None) # E: Cannot infer type of lambda \

# E: Argument 1 to "Z" has incompatible type "Callable[[Any, Any], None]"; expected "Callable[[int], None]"

Z[[int]](f1) # E: Argument 1 to "Z" has incompatible type "Callable[[str], None]"; expected "Callable[[int], None]"

Z[[]](lambda one: None) # E: Cannot infer type of lambda \

# E: Argument 1 to "Z" has incompatible type "Callable[[Any], None]"; expected "Callable[[], None]"

Z[bytes, str](lambda one: None) # E: Cannot infer type of lambda \

# E: Argument 1 to "Z" has incompatible type "Callable[[Any], None]"; expected "Callable[[bytes, str], None]"

Z[bytes, str](f2) # E: Argument 1 to "Z" has incompatible type "Callable[[bytes, int], None]"; expected "Callable[[bytes, str], None]"

[builtins fixtures/paramspec.pyi]

[case testParamSpecLiteralEllipsis]

from typing_extensions import ParamSpec

from typing import Generic, Callable

P = ParamSpec("P")

class Z(Generic[P]):

def __init__(self: 'Z[P]', c: Callable[P, None]) -> None:

...

def f1() -> None: ...

def f2(*args: int) -> None: ...

def f3(a: int, *, b: bytes) -> None: ...

def f4(b: bytes) -> None: ...

argh: Callable[..., None] = f4

# check it works

Z[...](f1)

Z[...](f2)

Z[...](f3)

# check subtyping works

n: Z[...]

n = Z(f1)

n = Z(f2)

n = Z(f3)

[builtins fixtures/paramspec.pyi]

[case testParamSpecApplyConcatenateTwice]

from typing_extensions import ParamSpec, Concatenate

from typing import Generic, Callable, Optional

P = ParamSpec("P")

class C(Generic[P]):

# think PhantomData<T> from rust

phantom: Optional[Callable[P, None]]

def add_str(self) -> C[Concatenate[str, P]]:

return C[Concatenate[str, P]]()

def add_int(self) -> C[Concatenate[int, P]]:

return C[Concatenate[int, P]]()

def f(c: C[P]) -> None:

reveal_type(c) # N: Revealed type is "__main__.C[P`-1]"

n1 = c.add_str()

reveal_type(n1) # N: Revealed type is "__main__.C[[builtins.str, **P`-1]]"

n2 = n1.add_int()

reveal_type(n2) # N: Revealed type is "__main__.C[[builtins.int, builtins.str, **P`-1]]"

p1 = c.add_int()

reveal_type(p1) # N: Revealed type is "__main__.C[[builtins.int, **P`-1]]"

p2 = p1.add_str()

reveal_type(p2) # N: Revealed type is "__main__.C[[builtins.str, builtins.int, **P`-1]]"

[builtins fixtures/paramspec.pyi]

[case testParamSpecLiteralJoin]

from typing import Generic, Callable, Union

from typing_extensions import ParamSpec

_P = ParamSpec("_P")

class Job(Generic[_P]):

def __init__(self, target: Callable[_P, None]) -> None:

self.target = target

def func(

action: Union[Job[int], Callable[[int], None]],

) -> None:

job = action if isinstance(action, Job) else Job(action)

reveal_type(job) # N: Revealed type is "__main__.Job[[builtins.int]]"

[builtins fixtures/paramspec.pyi]

[case testApplyParamSpecToParamSpecLiterals]

from typing import TypeVar, Generic, Callable

from typing_extensions import ParamSpec

_P = ParamSpec("_P")

_R_co = TypeVar("_R_co", covariant=True)

class Job(Generic[_P, _R_co]):

def __init__(self, target: Callable[_P, _R_co]) -> None:

self.target = target

def run_job(job: Job[_P, None], *args: _P.args, **kwargs: _P.kwargs) -> None:

...

def func(job: Job[[int, str], None]) -> None:

run_job(job, 42, "Hello")

run_job(job, "Hello", 42) # E: Argument 2 to "run_job" has incompatible type "str"; expected "int" \

# E: Argument 3 to "run_job" has incompatible type "int"; expected "str"

run_job(job, 42, msg="Hello") # E: Unexpected keyword argument "msg" for "run_job"

run_job(job, "Hello") # E: Too few arguments for "run_job" \

# E: Argument 2 to "run_job" has incompatible type "str"; expected "int"

def func2(job: Job[..., None]) -> None:

run_job(job, 42, "Hello")

run_job(job, "Hello", 42)

run_job(job, 42, msg="Hello")

run_job(job, x=42, msg="Hello")

[builtins fixtures/paramspec.pyi]

[case testExpandNonBareParamSpecAgainstCallable]

from typing import Callable, TypeVar, Any

from typing_extensions import ParamSpec

CallableT = TypeVar("CallableT", bound=Callable[..., Any])

_P = ParamSpec("_P")

_R = TypeVar("_R")

def simple_decorator(callable: CallableT) -> CallableT:

# set some attribute on 'callable'

return callable

class A:

@simple_decorator

def func(self, action: Callable[_P, _R], *args: _P.args, **kwargs: _P.kwargs) -> _R:

...

reveal_type(A.func) # N: Revealed type is "def [_P, _R] (self: __main__.A, action: def (*_P.args, **_P.kwargs) -> _R`4, *_P.args, **_P.kwargs) -> _R`4"

reveal_type(A().func) # N: Revealed type is "def [_P, _R] (action: def (*_P.args, **_P.kwargs) -> _R`8, *_P.args, **_P.kwargs) -> _R`8"

def f(x: int) -> int:

...

reveal_type(A().func(f, 42)) # N: Revealed type is "builtins.int"

reveal_type(A().func(lambda x: x + x, 42)) # N: Revealed type is "builtins.int"

[builtins fixtures/paramspec.pyi]

[case testParamSpecConstraintOnOtherParamSpec]

from typing import Callable, TypeVar, Any, Generic

from typing_extensions import ParamSpec

CallableT = TypeVar("CallableT", bound=Callable[..., Any])

_P = ParamSpec("_P")

_R_co = TypeVar("_R_co", covariant=True)

def simple_decorator(callable: CallableT) -> CallableT:

...

class Job(Generic[_P, _R_co]):

def __init__(self, target: Callable[_P, _R_co]) -> None:

...

class A:

@simple_decorator

def func(self, action: Job[_P, None]) -> Job[_P, None]:

...

reveal_type(A.func) # N: Revealed type is "def [_P] (self: __main__.A, action: __main__.Job[_P`3, None]) -> __main__.Job[_P`3, None]"

reveal_type(A().func) # N: Revealed type is "def [_P] (action: __main__.Job[_P`5, None]) -> __main__.Job[_P`5, None]"

reveal_type(A().func(Job(lambda x: x))) # N: Revealed type is "__main__.Job[[x: Any], None]"

def f(x: int, y: int) -> None: ...

reveal_type(A().func(Job(f))) # N: Revealed type is "__main__.Job[[x: builtins.int, y: builtins.int], None]"

[builtins fixtures/paramspec.pyi]

[case testConstraintBetweenParamSpecFunctions1]

from typing import Callable, TypeVar, Any, Generic

from typing_extensions import ParamSpec

_P = ParamSpec("_P")

_R_co = TypeVar("_R_co", covariant=True)

def simple_decorator(callable: Callable[_P, _R_co]) -> Callable[_P, _R_co]: ...

class Job(Generic[_P]): ...

@simple_decorator

def func(__action: Job[_P]) -> Callable[_P, None]:

...

reveal_type(func) # N: Revealed type is "def [_P] (__main__.Job[_P`-1]) -> def (*_P.args, **_P.kwargs)"

[builtins fixtures/paramspec.pyi]

[case testConstraintBetweenParamSpecFunctions2]

from typing import Callable, TypeVar, Any, Generic

from typing_extensions import ParamSpec

CallableT = TypeVar("CallableT", bound=Callable[..., Any])

_P = ParamSpec("_P")

def simple_decorator(callable: CallableT) -> CallableT: ...

class Job(Generic[_P]): ...

@simple_decorator

def func(__action: Job[_P]) -> Callable[_P, None]:

...

reveal_type(func) # N: Revealed type is "def [_P] (__main__.Job[_P`-1]) -> def (*_P.args, **_P.kwargs)"

[builtins fixtures/paramspec.pyi]

[case testConstraintsBetweenConcatenatePrefixes]

from typing import Any, Callable, Generic, TypeVar