check-kwargs.test

-- Test cases for keyword arguments.


[case testTypeErrorInKeywordArgument]
import typing
def f(o: object) -> None: pass
f(o=None()) # E: "None" not callable

[case testSimpleKeywordArgument]
import typing
class A: pass
def f(a: 'A') -> None: pass
f(a=A())
f(a=object()) # E: Argument "a" to "f" has incompatible type "object"; expected "A"

[case testTwoKeywordArgumentsNotInOrder]
import typing
class A: pass
class B: pass
def f(a: 'A', b: 'B') -> None: pass
f(b=A(), a=A()) # E: Argument "b" to "f" has incompatible type "A"; expected "B"
f(b=B(), a=B()) # E: Argument "a" to "f" has incompatible type "B"; expected "A"
f(a=A(), b=B())
f(b=B(), a=A())

[case testOneOfSeveralOptionalKeywordArguments]
# flags: --implicit-optional
import typing
class A: pass
class B: pass
class C: pass
def f(a: 'A' = None, b: 'B' = None, c: 'C' = None) -> None: pass
f(a=A())
f(b=B())
f(c=C())
f(b=B(), c=C())
f(a=B()) # E: Argument "a" to "f" has incompatible type "B"; expected "A | None"
f(b=A()) # E: Argument "b" to "f" has incompatible type "A"; expected "B | None"
f(c=B()) # E: Argument "c" to "f" has incompatible type "B"; expected "C | None"
f(b=B(), c=A()) # E: Argument "c" to "f" has incompatible type "A"; expected "C | None"
[case testBothPositionalAndKeywordArguments]
import typing
class A: pass
class B: pass
def f(a: 'A', b: 'B') -> None: pass
f(A(), b=A()) # E: Argument "b" to "f" has incompatible type "A"; expected "B"
f(A(), b=B())

[case testContextSensitiveTypeInferenceForKeywordArg]
from typing import List
class A: pass
def f(a: 'A', b: 'List[A]') -> None: pass
f(b=[], a=A())
[builtins fixtures/list.pyi]

[case testGivingArgumentAsPositionalAndKeywordArg]
# flags: --no-strict-optional
import typing
class A: pass
class B: pass
def f(a: 'A', b: 'B' = None) -> None: pass
f(A(), a=A()) # E: "f" gets multiple values for keyword argument "a"

[case testGivingArgumentAsPositionalAndKeywordArg2]
# flags: --no-strict-optional
import typing
class A: pass
class B: pass
def f(a: 'A' = None, b: 'B' = None) -> None: pass
f(A(), a=A()) # E: "f" gets multiple values for keyword argument "a"

[case testPositionalAndKeywordForSameArg]
# This used to crash in check_argument_count(). See #1095.
def f(a: int): pass
def g(): f(0, a=1)
[out]

[case testInvalidKeywordArgument]
import typing
def f(a: 'A') -> None: pass
f(b=object()) # E: Unexpected keyword argument "b" for "f"
class A: pass

[case testKeywordMisspelling]
class A: pass
def f(other: 'A') -> None: pass
f(otter=A()) # E: Unexpected keyword argument "otter" for "f"; did you mean "other"?

[case testMultipleKeywordsForMisspelling]
class A: pass
class B: pass
def f(thing : 'A', other: 'A', atter: 'A', btter: 'B') -> None: pass
f(otter=A()) # E: Unexpected keyword argument "otter" for "f"; did you mean "atter" or "other"?

[case testKeywordMisspellingDifferentType]
class A: pass
class B: pass
def f(other: 'A') -> None: pass
f(otter=B()) # E: Unexpected keyword argument "otter" for "f"; did you mean "other"?

[case testKeywordMisspellingInheritance]
class A: pass
class B(A): pass
class C: pass
def f(atter: 'A', btter: 'B', ctter: 'C') -> None: pass
f(otter=B()) # E: Unexpected keyword argument "otter" for "f"; did you mean "atter" or "btter"?

[case testKeywordMisspellingFloatInt]
def f(atter: float, btter: int) -> None: pass
x: int = 5
f(otter=x) # E: Unexpected keyword argument "otter" for "f"; did you mean "atter" or "btter"?

[case testKeywordMisspellingVarArgs]
class A: pass
def f(other: 'A', *atter: 'A') -> None: pass
f(otter=A()) # E: Unexpected keyword argument "otter" for "f"; did you mean "other"?
[builtins fixtures/tuple.pyi]

[case testKeywordMisspellingOnlyVarArgs]
class A: pass
def f(*other: 'A') -> None: pass
f(otter=A()) # E: Unexpected keyword argument "otter" for "f"
[builtins fixtures/tuple.pyi]

[case testKeywordMisspellingVarArgsDifferentTypes]
class A: pass
class B: pass
def f(other: 'B', *atter: 'A') -> None: pass
f(otter=A()) # E: Unexpected keyword argument "otter" for "f"; did you mean "other"?
[builtins fixtures/tuple.pyi]

[case testKeywordMisspellingVarKwargs]
class A: pass
def f(other: 'A', **atter: 'A') -> None: pass
f(otter=A()) # E: Missing positional argument "other" in call to "f"
[builtins fixtures/dict.pyi]

[case testKeywordArgumentsWithDynamicallyTypedCallable]
from typing import Any
f: Any
f(x=f(), z=None()) # E: "None" not callable
f(f, zz=None()) # E: "None" not callable
f(x=None)

[case testKeywordArgumentWithFunctionObject]
from typing import Callable
class A: pass
class B: pass
f: Callable[[A, B], None]
f(a=A(), b=B())  # E: Unexpected keyword argument "a"  # E: Unexpected keyword argument "b"
f(A(), b=B())  # E: Unexpected keyword argument "b"

[case testKeywordOnlyArguments]
# flags: --no-strict-optional
import typing
class A: pass
class B: pass
def f(a: 'A', *, b: 'B' = None) -> None: pass
def g(a: 'A', *, b: 'B') -> None: pass
def h(a: 'A', *, b: 'B', aa: 'A') -> None: pass
def i(a: 'A', *, b: 'B', aa: 'A' = None) -> None: pass
f(A(), b=B())
f(b=B(), a=A())
f(A())
f(A(), B()) # E: Too many positional arguments for "f"
g(A(), b=B())
g(b=B(), a=A())
g(A()) # E: Missing named argument "b" for "g"
g(A(), B()) # E: Too many positional arguments for "g"
h(A()) # E: Missing named argument "b" for "h" # E: Missing named argument "aa" for "h"
h(A(), b=B()) # E: Missing named argument "aa" for "h"
h(A(), aa=A()) # E: Missing named argument "b" for "h"
h(A(), b=B(), aa=A())
h(A(), aa=A(), b=B())
i(A()) # E: Missing named argument "b" for "i"
i(A(), b=B())
i(A(), aa=A()) # E: Missing named argument "b" for "i"
i(A(), b=B(), aa=A())
i(A(), aa=A(), b=B())

[case testKeywordOnlyArgumentsFastparse]
# flags: --no-strict-optional
import typing

class A: pass
class B: pass

def f(a: 'A', *, b: 'B' = None) -> None: pass
def g(a: 'A', *, b: 'B') -> None: pass
def h(a: 'A', *, b: 'B', aa: 'A') -> None: pass
def i(a: 'A', *, b: 'B', aa: 'A' = None) -> None: pass
f(A(), b=B())
f(b=B(), a=A())
f(A())
f(A(), B()) # E: Too many positional arguments for "f"
g(A(), b=B())
g(b=B(), a=A())
g(A()) # E: Missing named argument "b" for "g"
g(A(), B()) # E: Too many positional arguments for "g"
h(A()) # E: Missing named argument "b" for "h" # E: Missing named argument "aa" for "h"
h(A(), b=B()) # E: Missing named argument "aa" for "h"
h(A(), aa=A()) # E: Missing named argument "b" for "h"
h(A(), b=B(), aa=A())
h(A(), aa=A(), b=B())
i(A()) # E: Missing named argument "b" for "i"
i(A(), b=B())
i(A(), aa=A()) # E: Missing named argument "b" for "i"
i(A(), b=B(), aa=A())
i(A(), aa=A(), b=B())
[case testKwargsAfterBareArgs]
from typing import Tuple, Any
def f(a, *, b=None) -> None: pass
a = None  # type: Any
b = None  # type: Any
f(a, **b)

[builtins fixtures/dict.pyi]

[case testKeywordArgAfterVarArgs]
# flags: --implicit-optional
import typing
class A: pass
class B: pass
def f(*a: 'A', b: 'B' = None) -> None: pass
f()
f(A())
f(A(), A())
f(b=B())
f(A(), b=B())
f(A(), A(), b=B())
f(B())      # E: Argument 1 to "f" has incompatible type "B"; expected "A"
f(A(), B()) # E: Argument 2 to "f" has incompatible type "B"; expected "A"
f(b=A())    # E: Argument "b" to "f" has incompatible type "A"; expected "B | None"
[builtins fixtures/list.pyi]

[case testKeywordArgAfterVarArgsWithBothCallerAndCalleeVarArgs]
# flags: --implicit-optional --no-strict-optional
from typing import List
class A: pass
class B: pass
def f(*a: 'A', b: 'B' = None) -> None: pass
a = None # type: List[A]
f(*a)
f(A(), *a)
f(b=B())
f(*a, b=B())
f(A(), *a, b=B())
f(A(), B())   # E: Argument 2 to "f" has incompatible type "B"; expected "A"
f(A(), b=A()) # E: Argument "b" to "f" has incompatible type "A"; expected "B | None"
f(*a, b=A())  # E: Argument "b" to "f" has incompatible type "A"; expected "B | None"
[builtins fixtures/list.pyi]

[case testCallingDynamicallyTypedFunctionWithKeywordArgs]
import typing
class A: pass
def f(x, y=A()): pass
f(x=A(), y=A())
f(y=A(), x=A())
f(y=A())      # E: Missing positional argument "x" in call to "f"
f(A(), z=A()) # E: Unexpected keyword argument "z" for "f"

[case testKwargsArgumentInFunctionBody]
from typing import Dict, Any
def f( **kwargs: 'A') -> None:
    d1 = kwargs # type: Dict[str, A]
    d2 = kwargs # type: Dict[A, Any] # E: Incompatible types in assignment (expression has type "dict[str, A]", variable has type "dict[A, Any]")
    d3 = kwargs # type: Dict[Any, str] # E: Incompatible types in assignment (expression has type "dict[str, A]", variable has type "dict[Any, str]")
class A: pass
[builtins fixtures/dict.pyi]
[out]

[case testKwargsArgumentInFunctionBodyWithImplicitAny]
from typing import Dict, Any
def f(**kwargs) -> None:
    d1 = kwargs # type: Dict[str, A]
    d2 = kwargs # type: Dict[str, str]
    d3 = kwargs # type: Dict[A, Any] # E: Incompatible types in assignment (expression has type "dict[str, Any]", variable has type "dict[A, Any]")
class A: pass
[builtins fixtures/dict.pyi]
[out]

[case testCallingFunctionThatAcceptsVarKwargs]
import typing
class A: pass
class B: pass
def f( **kwargs: 'A') -> None: pass
f()
f(x=A())
f(y=A(), z=A())
f(x=B()) # E: Argument "x" to "f" has incompatible type "B"; expected "A"
f(A())   # E: Too many arguments for "f"
# Perhaps a better message would be "Too many *positional* arguments..."
[builtins fixtures/dict.pyi]

[case testCallingFunctionWithKeywordVarArgs]
from typing import Dict
class A: pass
class B: pass
def f( **kwargs: 'A') -> None: pass
d: Dict[str, A]
f(**d)
f(x=A(), **d)
d2: Dict[str, B]
f(**d2)         # E: Argument 1 to "f" has incompatible type "**dict[str, B]"; expected "A" \
                # N: Consider annotating the ** argument as "**kwargs: Any" or using a TypedDict
f(x=A(), **d2)  # E: Argument 2 to "f" has incompatible type "**dict[str, B]"; expected "A" \
                # N: Consider annotating the ** argument as "**kwargs: Any" or using a TypedDict
f(**{'x': B()}) # E: Argument 1 to "f" has incompatible type "**dict[str, B]"; expected "A" \
                # N: Consider annotating the ** argument as "**kwargs: Any" or using a TypedDict
[builtins fixtures/dict.pyi]

[case testIncompatibleKwargsNote]
from typing import Any
def f(x: int, y: str) -> None: pass
d: dict[str, int] = {}
f(**d)  # E: Argument 1 to "f" has incompatible type "**dict[str, int]"; expected "str" \
        # N: Consider annotating the ** argument as "**kwargs: Any" or using a TypedDict
[builtins fixtures/dict.pyi]

[case testKwargsAllowedInDunderCall]
class Formatter:
    def __call__(self, message: str, bold: bool = False) -> str:
        pass

formatter = Formatter()
formatter("test", bold=True)
reveal_type(formatter.__call__)  # N: Revealed type is "def (message: builtins.str, bold: builtins.bool =) -> builtins.str"
[builtins fixtures/bool.pyi]
[out]

[case testKwargsAllowedInDunderCallKwOnly]
class Formatter:
    def __call__(self, message: str, *, bold: bool = False) -> str:
        pass

formatter = Formatter()
formatter("test", bold=True)
reveal_type(formatter.__call__)  # N: Revealed type is "def (message: builtins.str, *, bold: builtins.bool =) -> builtins.str"
[builtins fixtures/bool.pyi]
[out]

[case testPassingMappingForKeywordVarArg]
from typing import Mapping
def f(**kwargs: 'A') -> None: pass
b: Mapping
d: Mapping[A, A]
m: Mapping[str, A]
f(**d)         # E: Argument after ** must have string keys
f(**m)
f(**b)
class A: pass
[builtins fixtures/dict.pyi]

[case testPassingMappingSubclassForKeywordVarArg]
from typing import Mapping
class MappingSubclass(Mapping[str, str]): pass
def f(**kwargs: 'A') -> None: pass
d: MappingSubclass
f(**d)  # E: Argument 1 to "f" has incompatible type "**MappingSubclass"; expected "A"
class A: pass
[builtins fixtures/dict.pyi]

[case testInvalidTypeForKeywordVarArg]
from typing import Dict, Any, Optional
class A: pass
def f(**kwargs: 'A') -> None: pass
d = {} # type: Dict[A, A]
f(**d)         # E: Argument after ** must have string keys
f(**A())       # E: Argument after ** must be a mapping, not "A"
kwargs: Optional[Any]
f(**kwargs)    # E: Argument after ** must be a mapping, not "Any | None"

def g(a: int) -> None: pass
g(a=1, **4)  # E: Argument after ** must be a mapping, not "int"

def main(f: Any) -> None:
    f(**3)  # E: Argument after ** must be a mapping, not "int"
[builtins fixtures/dict.pyi]

[case testPassingKeywordVarArgsToNonVarArgsFunction]
from typing import Any, Dict
def f(a: 'A', b: 'B') -> None: pass
d: Dict[str, Any]
f(**d)
d2: Dict[str, A]
f(**d2) # E: Argument 1 to "f" has incompatible type "**dict[str, A]"; expected "B" \
        # N: Consider annotating the ** argument as "**kwargs: Any" or using a TypedDict
class A: pass
class B: pass
[builtins fixtures/dict.pyi]

[case testBothKindsOfVarArgs]
from typing import Any, List, Dict
def f(a: 'A', b: 'A') -> None: pass
l: List[Any]
d: Dict[Any, Any]
f(*l, **d)
class A: pass
[builtins fixtures/dict.pyi]

[case testPassingMultipleKeywordVarArgs]
from typing import Any, Dict
def f1(a: 'A', b: 'A') -> None: pass
def f2(a: 'A') -> None: pass
def f3(a: 'A', **kwargs: 'A') -> None: pass
def f4(**kwargs: 'A') -> None: pass
d: Dict[Any, Any]
d2: Dict[Any, Any]
f1(**d, **d2)
f2(**d, **d2)
f3(**d, **d2)
f4(**d, **d2)
class A: pass
[builtins fixtures/dict.pyi]

[case testPassingKeywordVarArgsToVarArgsOnlyFunction]
from typing import Any, Dict
def f(*args: 'A') -> None: pass
d: Dict[Any, Any]
f(**d)
class A: pass
[builtins fixtures/dict.pyi]

[case testKeywordArgumentAndCommentSignature]
import typing
def f(x): # type: (int) -> str
    pass
f(x='') # E: Argument "x" to "f" has incompatible type "str"; expected "int"
f(x=0)
f(y=0) # E: Unexpected keyword argument "y" for "f"

[case testKeywordArgumentAndCommentSignature2]
import typing
class A:
    def f(self, x): # type: (int) -> str
        pass
A().f(x='') # E: Argument "x" to "f" of "A" has incompatible type "str"; expected "int"
A().f(x=0)
A().f(y=0) # E: Unexpected keyword argument "y" for "f" of "A"

[case testKeywordVarArgsAndCommentSignature]
import typing
def f(**kwargs): # type: (**int) -> None
    pass
f(z=1)
f(x=1, y=1)
f(x='', y=1) # E: Argument "x" to "f" has incompatible type "str"; expected "int"
f(x=1, y='') # E: Argument "y" to "f" has incompatible type "str"; expected "int"
[builtins fixtures/dict.pyi]

[case testCallsWithStars]
def f(a: int) -> None:
    pass

s = ('',)
f(*s) # E: Argument 1 to "f" has incompatible type "*tuple[str]"; expected "int"

a = {'': 0}
f(a) # E: Argument 1 to "f" has incompatible type "dict[str, int]"; expected "int"
f(**a) # okay

b = {'': ''}
f(b) # E: Argument 1 to "f" has incompatible type "dict[str, str]"; expected "int"
f(**b) # E: Argument 1 to "f" has incompatible type "**dict[str, str]"; expected "int" \
       # N: Consider annotating the ** argument as "**kwargs: Any" or using a TypedDict

c = {0: 0}
f(**c) # E: Argument after ** must have string keys
[builtins fixtures/dict.pyi]

[case testCallStar2WithStar]
def f(**k): pass
f(*(1, 2))  # E: Too many arguments for "f"
[builtins fixtures/dict.pyi]

[case testUnexpectedMethodKwargInNestedClass]
class A:
    class B:
        def __init__(self) -> None:
            pass
A.B(x=1)  # E: Unexpected keyword argument "x" for "B"

[case testUnexpectedMethodKwargFromOtherModule]
import m
m.A(x=1)
[file m.py]
1+'asdf'
class A:
    def __init__(self) -> None:
        pass
[out]
tmp/m.py:1: error: Unsupported operand types for + ("int" and "str")
main:2: error: Unexpected keyword argument "x" for "A"
main:2: note: "A" defined in "m"

[case testMissingNamedArgumentFromOtherModule]
import m
m.f(1)
m.f(a=1)
[file m.py]
def f(a: int, *, b: str) -> None:
    pass
[out]
main:2: error: Missing named argument "b" for "f"
main:2: note: "f" defined in "m"
main:3: error: Missing named argument "b" for "f"
main:3: note: "f" defined in "m"

[case testMissingNamedArgumentForSameModule]
def f(a: int, *, b: str) -> None:
    pass
f(1)  # E: Missing named argument "b" for "f"

[case testStarArgsAndKwArgsSpecialCase]
from typing import Dict, Mapping

def f(*vargs: int, **kwargs: object) -> None:
	pass

def g(arg: int = 0, **kwargs: object) -> None:
	pass

d = {} # type: Dict[str, object]
f(**d)
g(**d)  # E: Argument 1 to "g" has incompatible type "**dict[str, object]"; expected "int" \
        # N: Consider annotating the ** argument as "**kwargs: Any" or using a TypedDict

m = {} # type: Mapping[str, object]
f(**m)
g(**m)  # E: Argument 1 to "g" has incompatible type "**Mapping[str, object]"; expected "int"
[builtins fixtures/dict.pyi]

[case testPassingEmptyDictWithStars]
def f(): pass
def g(x=1): pass

f(**{})
g(**{})
[builtins fixtures/dict.pyi]

[case testKeywordUnpackWithDifferentTypes]
# https://github.com/python/mypy/issues/11144
from typing import Dict, Generic, TypeVar, Mapping, Iterable

T = TypeVar("T")
T2 = TypeVar("T2")

class A(Dict[T, T2]):
    ...

class B(Mapping[T, T2]):
    ...

class C(Generic[T, T2]):
    ...

class D:
    ...

class E:
    def keys(self) -> Iterable[str]:
        ...
    def __getitem__(self, key: str) -> float:
        ...

def foo(**i: float) -> float:
    ...

a: A[str, str]
b: B[str, str]
c: C[str, float]
d: D
e: E
f = {"a": "b"}

foo(k=1.5)
foo(**a)
foo(**b)
foo(**c)
foo(**d)
foo(**e)
foo(**f)

# Correct:

class Good(Mapping[str, float]):
    ...

good1: Good
good2: A[str, float]
good3: B[str, float]
foo(**good1)
foo(**good2)
foo(**good3)
[out]
main:36: error: Argument 1 to "foo" has incompatible type "**A[str, str]"; expected "float"
main:37: error: Argument 1 to "foo" has incompatible type "**B[str, str]"; expected "float"
main:38: error: Argument after ** must be a mapping, not "C[str, float]"
main:39: error: Argument after ** must be a mapping, not "D"
main:41: error: Argument 1 to "foo" has incompatible type "**dict[str, str]"; expected "float"
main:41: note: Consider annotating the ** argument as "**kwargs: Any" or using a TypedDict
[builtins fixtures/dict.pyi]

[case testLiteralKwargs]
from typing import Any, Literal
kw: dict[Literal["a", "b"], Any]
def func(a, b): ...
func(**kw)

badkw: dict[Literal["one", 1], Any]
func(**badkw)  # E: Argument after ** must have string keys
[builtins fixtures/dict.pyi]