Google Git Google Git
Sign in
fuchsia/third_party/github.com/python/mypy/46e199dacf3cf8a1792b0a0ee560a2d865906ab2/./test-data/unit/check-dataclasses.test
blob: d269ad2bad0ecd71564b6ac9d1bb830f4eaf8c9f [file]
[case testDataclassesBasic]
from dataclasses import dataclass
@dataclass
class Person:
name: str
age: int
def summary(self):
return "%s is %d years old." % (self.name, self.age)
reveal_type(Person) # N: Revealed type is "def (name: builtins.str, age: builtins.int) -> __main__.Person"
Person('John', 32)
Person('Jonh', 21, None) # E: Too many arguments for "Person"
[builtins fixtures/dataclasses.pyi]
[typing fixtures/typing-medium.pyi]
[case testDataclassesCustomInit]
from dataclasses import dataclass
@dataclass
class A:
a: int
def __init__(self, a: str) -> None:
pass
A('1')
[builtins fixtures/dataclasses.pyi]
[case testDataclassesBasicInheritance]
from dataclasses import dataclass
@dataclass
class Mammal:
age: int
@dataclass
class Person(Mammal):
name: str
def summary(self):
return "%s is %d years old." % (self.name, self.age)
reveal_type(Person) # N: Revealed type is "def (age: builtins.int, name: builtins.str) -> __main__.Person"
Mammal(10)
Person(32, 'John')
Person(21, 'Jonh', None) # E: Too many arguments for "Person"
[builtins fixtures/dataclasses.pyi]
[typing fixtures/typing-medium.pyi]
[case testDataclassesDeepInheritance]
from dataclasses import dataclass
@dataclass
class A:
a: int
@dataclass
class B(A):
b: int
@dataclass
class C(B):
c: int
@dataclass
class D(C):
d: int
reveal_type(A) # N: Revealed type is "def (a: builtins.int) -> __main__.A"
reveal_type(B) # N: Revealed type is "def (a: builtins.int, b: builtins.int) -> __main__.B"
reveal_type(C) # N: Revealed type is "def (a: builtins.int, b: builtins.int, c: builtins.int) -> __main__.C"
reveal_type(D) # N: Revealed type is "def (a: builtins.int, b: builtins.int, c: builtins.int, d: builtins.int) -> __main__.D"
[builtins fixtures/dataclasses.pyi]
[case testDataclassesMultipleInheritance]
from dataclasses import dataclass, field, InitVar
@dataclass
class A:
a: bool
@dataclass
class B:
b: InitVar[bool]
_b: bool = field(init=False)
def __post_init__(self, b: bool):
self._b = b
@dataclass
class C(A, B):
pass
reveal_type(C) # N: Revealed type is "def (b: builtins.bool, a: builtins.bool) -> __main__.C"
[builtins fixtures/dataclasses.pyi]
[case testDataclassesDeepInitVarInheritance]
from dataclasses import dataclass, field, InitVar
@dataclass
class A:
a: bool
@dataclass
class B:
b: InitVar[bool]
_b: bool = field(init=False)
def __post_init__(self, b: bool):
self._b = b
@dataclass(init=False)
class C(B):
def __init__(self):
super().__init__(True)
@dataclass
class D(C):
pass
reveal_type(C) # N: Revealed type is "def () -> __main__.C"
reveal_type(D) # N: Revealed type is "def (b: builtins.bool) -> __main__.D"
[builtins fixtures/dataclasses.pyi]
[case testDataclassesOverriding]
from dataclasses import dataclass
@dataclass
class Mammal:
age: int
@dataclass
class Person(Mammal):
name: str
age: int
@dataclass
class SpecialPerson(Person):
special_factor: float
@dataclass
class ExtraSpecialPerson(SpecialPerson):
age: int
special_factor: float
name: str
reveal_type(Person) # N: Revealed type is "def (age: builtins.int, name: builtins.str) -> __main__.Person"
reveal_type(SpecialPerson) # N: Revealed type is "def (age: builtins.int, name: builtins.str, special_factor: builtins.float) -> __main__.SpecialPerson"
reveal_type(ExtraSpecialPerson) # N: Revealed type is "def (age: builtins.int, name: builtins.str, special_factor: builtins.float) -> __main__.ExtraSpecialPerson"
Person(32, 'John')
Person(21, 'John', None) # E: Too many arguments for "Person"
SpecialPerson(21, 'John', 0.5)
ExtraSpecialPerson(21, 'John', 0.5)
[builtins fixtures/dataclasses.pyi]
[case testDataclassesOverridingWithDefaults]
# Issue #5681 https://github.com/python/mypy/issues/5681
from dataclasses import dataclass
from typing import Any
@dataclass
class Base:
some_int: Any
some_str: str = 'foo'
@dataclass
class C(Base):
some_int: int
reveal_type(C) # N: Revealed type is "def (some_int: builtins.int, some_str: builtins.str =) -> __main__.C"
[builtins fixtures/dataclasses.pyi]
[case testDataclassIncompatibleOverrides]
from dataclasses import dataclass
@dataclass
class Base:
foo: int
@dataclass
class BadDerived1(Base):
def foo(self) -> int: # E: Dataclass attribute may only be overridden by another attribute \
# E: Signature of "foo" incompatible with supertype "Base" \
# N: Superclass: \
# N: int \
# N: Subclass: \
# N: def foo(self) -> int
return 1
@dataclass
class BadDerived2(Base):
@property # E: Dataclass attribute may only be overridden by another attribute
def foo(self) -> int: # E: Cannot override writeable attribute with read-only property
return 2
@dataclass
class BadDerived3(Base):
class foo: pass # E: Dataclass attribute may only be overridden by another attribute
[builtins fixtures/dataclasses.pyi]
[case testDataclassMultipleInheritance]
from dataclasses import dataclass
class Unrelated:
foo: str
@dataclass
class Base:
bar: int
@dataclass
class Derived(Base, Unrelated):
pass
d = Derived(3)
reveal_type(d.foo) # N: Revealed type is "builtins.str"
reveal_type(d.bar) # N: Revealed type is "builtins.int"
[builtins fixtures/dataclasses.pyi]
[case testDataclassIncompatibleFrozenOverride]
from dataclasses import dataclass
@dataclass(frozen=True)
class Base:
foo: int
@dataclass(frozen=True)
class BadDerived(Base):
@property # E: Dataclass attribute may only be overridden by another attribute
def foo(self) -> int:
return 3
[builtins fixtures/dataclasses.pyi]
[case testDataclassesFreezing]
from dataclasses import dataclass
@dataclass(frozen=True)
class Person:
name: str
john = Person('John')
john.name = 'Ben' # E: Property "name" defined in "Person" is read-only
[builtins fixtures/dataclasses.pyi]
[case testDataclassesInconsistentFreezing]
from dataclasses import dataclass
@dataclass(frozen=True)
class FrozenBase:
pass
@dataclass
class BadNormalDerived(FrozenBase): # E: Non-frozen dataclass cannot inherit from a frozen dataclass
pass
@dataclass
class NormalBase:
pass
@dataclass(frozen=True)
class BadFrozenDerived(NormalBase): # E: Frozen dataclass cannot inherit from a non-frozen dataclass
pass
[builtins fixtures/dataclasses.pyi]
[case testDataclassesFields]
from dataclasses import dataclass, field
@dataclass
class Person:
name: str
age: int = field(default=0, init=False)
reveal_type(Person) # N: Revealed type is "def (name: builtins.str) -> __main__.Person"
john = Person('John')
john.age = 'invalid' # E: Incompatible types in assignment (expression has type "str", variable has type "int")
john.age = 24
[builtins fixtures/dataclasses.pyi]
[case testDataclassesBadInit]
from dataclasses import dataclass, field
@dataclass
class Person:
name: str
age: int = field(init=None) # E: No overload variant of "field" matches argument type "None" \
# N: Possible overload variants: \
# N: def [_T] field(*, default: _T, init: bool = ..., repr: bool = ..., hash: bool | None = ..., compare: bool = ..., metadata: Mapping[str, Any] | None = ..., kw_only: bool = ...) -> _T \
# N: def [_T] field(*, default_factory: Callable[[], _T], init: bool = ..., repr: bool = ..., hash: bool | None = ..., compare: bool = ..., metadata: Mapping[str, Any] | None = ..., kw_only: bool = ...) -> _T \
# N: def field(*, init: bool = ..., repr: bool = ..., hash: bool | None = ..., compare: bool = ..., metadata: Mapping[str, Any] | None = ..., kw_only: bool = ...) -> Any
[builtins fixtures/dataclasses.pyi]
[case testDataclassesMultiInit]
from dataclasses import dataclass, field
from typing import List
@dataclass
class Person:
name: str
age: int = field(init=False)
friend_names: List[str] = field(init=True)
enemy_names: List[str]
reveal_type(Person) # N: Revealed type is "def (name: builtins.str, friend_names: builtins.list[builtins.str], enemy_names: builtins.list[builtins.str]) -> __main__.Person"
[builtins fixtures/dataclasses.pyi]
[case testDataclassesMultiInitDefaults]
from dataclasses import dataclass, field
from typing import List, Optional
@dataclass
class Person:
name: str
age: int = field(init=False)
friend_names: List[str] = field(init=True)
enemy_names: List[str]
nickname: Optional[str] = None
reveal_type(Person) # N: Revealed type is "def (name: builtins.str, friend_names: builtins.list[builtins.str], enemy_names: builtins.list[builtins.str], nickname: builtins.str | None =) -> __main__.Person"
[builtins fixtures/dataclasses.pyi]
[case testDataclassesDefaults]
from dataclasses import dataclass
@dataclass
class Application:
name: str = 'Unnamed'
rating: int = 0
reveal_type(Application) # N: Revealed type is "def (name: builtins.str =, rating: builtins.int =) -> __main__.Application"
app = Application()
[builtins fixtures/dataclasses.pyi]
[case testDataclassesDefaultFactories]
from dataclasses import dataclass, field
@dataclass
class Application:
name: str = 'Unnamed'
rating: int = field(default_factory=int)
rating_count: int = field() # E: Attributes without a default cannot follow attributes with one
[builtins fixtures/dataclasses.pyi]
[case testDataclassesDefaultFactoryTypeChecking]
from dataclasses import dataclass, field
@dataclass
class Application:
name: str = 'Unnamed'
rating: int = field(default_factory=str) # E: Incompatible types in assignment (expression has type "str", variable has type "int")
[builtins fixtures/dataclasses.pyi]
[case testDataclassesDefaultOrdering]
from dataclasses import dataclass
@dataclass
class Application:
name: str = 'Unnamed'
rating: int # E: Attributes without a default cannot follow attributes with one
[builtins fixtures/dataclasses.pyi]
[case testDataclassesOrderingKwOnly]
from dataclasses import dataclass
@dataclass(kw_only=True)
class Application:
name: str = 'Unnamed'
rating: int
Application(rating=5)
Application(name='name', rating=5)
Application() # E: Missing named argument "rating" for "Application"
Application('name') # E: Too many positional arguments for "Application" # E: Missing named argument "rating" for "Application"
Application('name', 123) # E: Too many positional arguments for "Application"
Application('name', rating=123) # E: Too many positional arguments for "Application"
Application(name=123, rating='name') # E: Argument "name" to "Application" has incompatible type "int"; expected "str" # E: Argument "rating" to "Application" has incompatible type "str"; expected "int"
Application(rating='name', name=123) # E: Argument "rating" to "Application" has incompatible type "str"; expected "int" # E: Argument "name" to "Application" has incompatible type "int"; expected "str"
[builtins fixtures/dataclasses.pyi]
[case testDataclassesOrderingKwOnlyOnField]
from dataclasses import dataclass, field
@dataclass
class Application:
name: str = 'Unnamed'
rating: int = field(kw_only=True)
Application(rating=5)
Application('name', rating=123)
Application(name='name', rating=5)
Application() # E: Missing named argument "rating" for "Application"
Application('name') # E: Missing named argument "rating" for "Application"
Application('name', 123) # E: Too many positional arguments for "Application"
Application(123, rating='name') # E: Argument 1 to "Application" has incompatible type "int"; expected "str" # E: Argument "rating" to "Application" has incompatible type "str"; expected "int"
[builtins fixtures/dataclasses.pyi]
[case testDataclassesOrderingKwOnlyOnFieldFalse]
from dataclasses import dataclass, field
@dataclass
class Application:
name: str = 'Unnamed'
rating: int = field(kw_only=False) # E: Attributes without a default cannot follow attributes with one
Application(name='name', rating=5)
Application('name', 123)
Application('name', rating=123)
Application() # E: Missing positional argument "name" in call to "Application"
Application('name') # E: Too few arguments for "Application"
[builtins fixtures/dataclasses.pyi]
[case testDataclassesOrderingKwOnlyWithSentinel]
from dataclasses import dataclass, KW_ONLY
@dataclass
class Application:
_: KW_ONLY
name: str = 'Unnamed'
rating: int
Application(rating=5)
Application(name='name', rating=5)
Application() # E: Missing named argument "rating" for "Application"
Application('name') # E: Too many positional arguments for "Application" # E: Missing named argument "rating" for "Application"
Application('name', 123) # E: Too many positional arguments for "Application"
Application('name', rating=123) # E: Too many positional arguments for "Application"
[builtins fixtures/dataclasses.pyi]
[case testDataclassesOrderingKwOnlyWithPEP661Sentinel]
-- Regression test for KW_ONLY implemented as a PEP 661 sentinel, as in
-- https://github.com/python/cpython/commit/16952218d0535904236e8a39851133688c9ce1f0
-- `_is_kw_only_type` must recognize this shape too, or `_` stops being excluded
-- from `__init__` and kw-only ordering enforcement silently stops firing.
from dataclasses import dataclass, KW_ONLY
@dataclass
class Application:
_: KW_ONLY
name: str = 'Unnamed'
rating: int
Application(rating=5)
Application('name', 123) # E: Too many positional arguments for "Application"
[file dataclasses.pyi]
from typing import Any, Callable, TypeVar, overload
from typing_extensions import sentinel
_T = TypeVar("_T")
KW_ONLY = sentinel("KW_ONLY")
MISSING = sentinel("MISSING")
class Field:
default: Any
default_factory: Any
def field(
*,
default: Any = ...,
default_factory: Any = ...,
init: bool = ...,
repr: bool = ...,
hash: Any = ...,
compare: bool = ...,
metadata: Any = ...,
kw_only: Any = ...,
) -> Any: ...
@overload
def dataclass(cls: type[_T]) -> type[_T]: ...
@overload
def dataclass(
cls: None = ...,
*,
init: bool = ...,
repr: bool = ...,
eq: bool = ...,
order: bool = ...,
unsafe_hash: bool = ...,
frozen: bool = ...,
match_args: bool = ...,
kw_only: bool = ...,
slots: bool = ...,
weakref_slot: bool = ...,
) -> Callable[[type[_T]], type[_T]]: ...
[builtins fixtures/dataclasses.pyi]
[case testDataclassesOrderingKwOnlyWithSentinelAndFieldOverride]
from dataclasses import dataclass, field, KW_ONLY
@dataclass
class Application:
_: KW_ONLY
name: str = 'Unnamed'
rating: int = field(kw_only=False)
Application(name='name', rating=5)
Application() # E: Missing positional argument "rating" in call to "Application"
Application(123)
Application('name') # E: Argument 1 to "Application" has incompatible type "str"; expected "int"
Application('name', 123) # E: Too many positional arguments for "Application" \
# E: Argument 1 to "Application" has incompatible type "str"; expected "int" \
# E: Argument 2 to "Application" has incompatible type "int"; expected "str"
Application(123, rating=123) # E: "Application" gets multiple values for keyword argument "rating"
[builtins fixtures/dataclasses.pyi]
[case testDataclassesOrderingKwOnlyWithSentinelAndSubclass]
from dataclasses import dataclass, field, KW_ONLY
@dataclass
class Base:
x: str
_: KW_ONLY
y: int = 0
w: int = 1
@dataclass
class D(Base):
z: str
a: str = "a"
D("Hello", "World")
D(x="Hello", z="World")
D("Hello", "World", y=1, w=2, a="b")
D("Hello") # E: Missing positional argument "z" in call to "D"
D() # E: Missing positional arguments "x", "z" in call to "D"
D(123, "World") # E: Argument 1 to "D" has incompatible type "int"; expected "str"
D("Hello", False) # E: Argument 2 to "D" has incompatible type "bool"; expected "str"
D(123, False) # E: Argument 1 to "D" has incompatible type "int"; expected "str" # E: Argument 2 to "D" has incompatible type "bool"; expected "str"
[builtins fixtures/dataclasses.pyi]
[case testDataclassesOrderingKwOnlyWithMultipleSentinel]
from dataclasses import dataclass, field, KW_ONLY
@dataclass
class Base:
x: str
_: KW_ONLY
y: int = 0
__: KW_ONLY # E: There may not be more than one field with the KW_ONLY type
w: int = 1
[builtins fixtures/dataclasses.pyi]
[case testDataclassesClassmethods]
from dataclasses import dataclass
@dataclass
class Application:
name: str
@classmethod
def parse(cls, request: str) -> "Application":
return cls(name='...')
app = Application.parse('')
[builtins fixtures/dataclasses.pyi]
[case testDataclassesOverloadsAndClassmethods]
from dataclasses import dataclass
from typing import overload, Union
@dataclass
class A:
a: int
b: str
@classmethod
def other(cls) -> str:
return "..."
@overload
@classmethod
def foo(cls, x: int) -> int: ...
@overload
@classmethod
def foo(cls, x: str) -> str: ...
@classmethod
def foo(cls, x: Union[int, str]) -> Union[int, str]:
reveal_type(cls) # N: Revealed type is "type[__main__.A]"
reveal_type(cls.other()) # N: Revealed type is "builtins.str"
return x
reveal_type(A.foo(3)) # N: Revealed type is "builtins.int"
reveal_type(A.foo("foo")) # N: Revealed type is "builtins.str"
[builtins fixtures/dataclasses.pyi]
[case testClassmethodShadowingFieldDoesNotCrash]
from dataclasses import dataclass
# This used to crash -- see #6217
@dataclass
class Foo:
bar: str
@classmethod # E: Name "bar" already defined on line 6
def bar(cls) -> "Foo":
return cls('asdf')
[builtins fixtures/dataclasses.pyi]
[case testDataclassesClassVars]
from dataclasses import dataclass
from typing import ClassVar
@dataclass
class Application:
name: str
COUNTER: ClassVar[int] = 0
reveal_type(Application) # N: Revealed type is "def (name: builtins.str) -> __main__.Application"
application = Application("example")
application.COUNTER = 1 # E: Cannot assign to class variable "COUNTER" via instance
Application.COUNTER = 1
[builtins fixtures/dataclasses.pyi]
[case testTypeAliasInDataclassDoesNotCrash]
from dataclasses import dataclass
from typing import Callable
from typing_extensions import TypeAlias
@dataclass
class Foo:
x: int
@dataclass
class One:
S: TypeAlias = Foo # E: Type aliases inside dataclass definitions are not supported at runtime
a = One()
reveal_type(a.S) # N: Revealed type is "def (x: builtins.int) -> __main__.Foo"
a.S() # E: Missing positional argument "x" in call to "Foo"
reveal_type(a.S(5)) # N: Revealed type is "__main__.Foo"
@dataclass
class Two:
S: TypeAlias = Callable[[int], str] # E: Type aliases inside dataclass definitions are not supported at runtime
c = Two()
x = c.S
reveal_type(x) # N: Revealed type is "typing._SpecialForm"
[builtins fixtures/dataclasses.pyi]
[typing fixtures/typing-medium.pyi]
[case testFunctionAliasDataclassNoCrash]
from dataclasses import dataclass
def fn(a: int) -> int:
return a
@dataclass
class Test:
foo = fn
foo: int = 42 # E: Name "foo" already defined on line 8
reveal_type(Test.foo) # N: Revealed type is "def (a: builtins.int) -> builtins.int"
[builtins fixtures/dataclasses.pyi]
[typing fixtures/typing-medium.pyi]
[case testDataclassVariableBadRedefine]
from dataclasses import dataclass
@dataclass
class Test:
foo = "test"
foo: int = 42 # E: Name "foo" already defined on line 5
reveal_type(Test) # N: Revealed type is "def () -> __main__.Test"
reveal_type(Test.foo) # N: Revealed type is "builtins.str"
[builtins fixtures/dataclasses.pyi]
[typing fixtures/typing-medium.pyi]
[case testDataclassCallableAttrRegular]
from dataclasses import dataclass
from typing import Callable
@dataclass
class Defer(Parent):
b: int
@dataclass
class Parent:
key: Callable[[], str]
a: int
reveal_type(Parent) # N: Revealed type is "def (key: def () -> builtins.str, a: builtins.int) -> __main__.Parent"
[builtins fixtures/dataclasses.pyi]
[typing fixtures/typing-medium.pyi]
[case testDataclassCallableAttrDefault]
from dataclasses import dataclass
from typing import Callable
@dataclass
class Defer(Parent):
b: int = 0
@dataclass
class Parent:
key: Callable[[], str] = lambda: "yes"
a: int = 0
reveal_type(Parent) # N: Revealed type is "def (key: def () -> builtins.str =, a: builtins.int =) -> __main__.Parent"
reveal_type(Parent.key) # N: Revealed type is "def () -> builtins.str"
[builtins fixtures/dataclasses.pyi]
[typing fixtures/typing-medium.pyi]
[case testDataclassCallableAttrFrozen]
from dataclasses import dataclass
from typing import Callable
@dataclass(frozen=True)
class Defer(Parent):
b: int
@dataclass(frozen=True)
class Parent:
key: Callable[[], str]
a: int
reveal_type(Parent) # N: Revealed type is "def (key: def () -> builtins.str, a: builtins.int) -> __main__.Parent"
[builtins fixtures/dataclasses.pyi]
[typing fixtures/typing-medium.pyi]
[case testDataclassOrdering]
from dataclasses import dataclass
@dataclass(order=True)
class Application:
name: str
rating: int
app1 = Application('example-1', 5)
app2 = Application('example-2', 5)
app1 < app2
app1 > app2
app1 <= app2
app1 >= app2
app1 < 5 # E: Unsupported operand types for < ("Application" and "int")
app1 > 5 # E: Unsupported operand types for > ("Application" and "int")
app1 <= 5 # E: Unsupported operand types for <= ("Application" and "int")
app1 >= 5 # E: Unsupported operand types for >= ("Application" and "int")
class SpecializedApplication(Application):
...
app3 = SpecializedApplication('example-3', 5)
app1 < app3
app1 > app3
app1 <= app3
app1 >= app3
[builtins fixtures/dataclasses.pyi]
[case testDataclassOrderingWithoutEquality]
from dataclasses import dataclass
@dataclass(eq=False, order=True) # E: "eq" must be True if "order" is True
class Application:
...
[builtins fixtures/dataclasses.pyi]
[case testDataclassOrderingWithCustomMethods]
from dataclasses import dataclass
@dataclass(order=True)
class Application:
def __lt__(self, other: 'Application') -> bool: # E: You may not have a custom "__lt__" method when "order" is True
...
[builtins fixtures/dataclasses.pyi]
[case testDataclassDefaultsInheritance]
from dataclasses import dataclass
from typing import Optional
@dataclass(order=True)
class Application:
id: Optional[int]
name: str
@dataclass
class SpecializedApplication(Application):
rating: int = 0
reveal_type(SpecializedApplication) # N: Revealed type is "def (id: builtins.int | None, name: builtins.str, rating: builtins.int =) -> __main__.SpecializedApplication"
[builtins fixtures/dataclasses.pyi]
[case testDataclassGenerics]
from dataclasses import dataclass
from typing import Generic, List, Optional, TypeVar
T = TypeVar('T')
@dataclass
class A(Generic[T]):
x: T
y: T
z: List[T]
def foo(self) -> List[T]:
return [self.x, self.y]
def bar(self) -> T:
return self.z[0]
def problem(self) -> T:
return self.z # E: Incompatible return value type (got "list[T]", expected "T")
reveal_type(A) # N: Revealed type is "def [T] (x: T`1, y: T`1, z: builtins.list[T`1]) -> __main__.A[T`1]"
A(1, 2, ["a", "b"]) # E: Cannot infer value of type parameter "T" of "A"
a = A(1, 2, [1, 2])
reveal_type(a) # N: Revealed type is "__main__.A[builtins.int]"
reveal_type(a.x) # N: Revealed type is "builtins.int"
reveal_type(a.y) # N: Revealed type is "builtins.int"
reveal_type(a.z) # N: Revealed type is "builtins.list[builtins.int]"
s: str = a.bar() # E: Incompatible types in assignment (expression has type "int", variable has type "str")
[builtins fixtures/dataclasses.pyi]
[case testDataclassGenericCovariant]
from dataclasses import dataclass
from typing import Generic, TypeVar
T_co = TypeVar("T_co", covariant=True)
@dataclass
class MyDataclass(Generic[T_co]):
a: T_co
[builtins fixtures/dataclasses.pyi]
[case testDataclassUntypedGenericInheritance]
from dataclasses import dataclass
from typing import Generic, TypeVar
T = TypeVar("T")
@dataclass
class Base(Generic[T]):
attr: T
@dataclass
class Sub(Base):
pass
sub = Sub(attr=1)
reveal_type(sub) # N: Revealed type is "__main__.Sub"
reveal_type(sub.attr) # N: Revealed type is "Any"
[builtins fixtures/dataclasses.pyi]
[case testDataclassGenericSubtype]
from dataclasses import dataclass
from typing import Generic, TypeVar
T = TypeVar("T")
@dataclass
class Base(Generic[T]):
attr: T
S = TypeVar("S")
@dataclass
class Sub(Base[S]):
pass
sub_int = Sub[int](attr=1)
reveal_type(sub_int) # N: Revealed type is "__main__.Sub[builtins.int]"
reveal_type(sub_int.attr) # N: Revealed type is "builtins.int"
sub_str = Sub[str](attr='ok')
reveal_type(sub_str) # N: Revealed type is "__main__.Sub[builtins.str]"
reveal_type(sub_str.attr) # N: Revealed type is "builtins.str"
[builtins fixtures/dataclasses.pyi]
[case testDataclassGenericInheritance]
from dataclasses import dataclass
from typing import Generic, TypeVar
T1 = TypeVar("T1")
T2 = TypeVar("T2")
T3 = TypeVar("T3")
@dataclass
class Base(Generic[T1, T2, T3]):
one: T1
two: T2
three: T3
@dataclass
class Sub(Base[int, str, float]):
pass
sub = Sub(one=1, two='ok', three=3.14)
reveal_type(sub) # N: Revealed type is "__main__.Sub"
reveal_type(sub.one) # N: Revealed type is "builtins.int"
reveal_type(sub.two) # N: Revealed type is "builtins.str"
reveal_type(sub.three) # N: Revealed type is "builtins.float"
[builtins fixtures/dataclasses.pyi]
[case testDataclassMultiGenericInheritance]
from dataclasses import dataclass
from typing import Generic, TypeVar
T = TypeVar("T")
@dataclass
class Base(Generic[T]):
base_attr: T
S = TypeVar("S")
@dataclass
class Middle(Base[int], Generic[S]):
middle_attr: S
@dataclass
class Sub(Middle[str]):
pass
sub = Sub(base_attr=1, middle_attr='ok')
reveal_type(sub) # N: Revealed type is "__main__.Sub"
reveal_type(sub.base_attr) # N: Revealed type is "builtins.int"
reveal_type(sub.middle_attr) # N: Revealed type is "builtins.str"
[builtins fixtures/dataclasses.pyi]
[case testDataclassGenericsClassmethod]
from dataclasses import dataclass
from typing import Generic, TypeVar
T = TypeVar('T')
@dataclass
class A(Generic[T]):
x: T
@classmethod
def foo(cls) -> None:
reveal_type(cls) # N: Revealed type is "type[__main__.A[T`1]]"
cls.x # E: Cannot access instance-only attribute "x" on class object \
# E: Access to generic instance variables via class is ambiguous
@classmethod
def other(cls, x: T) -> A[T]: ...
reveal_type(A(0).other) # N: Revealed type is "def (x: builtins.int) -> __main__.A[builtins.int]"
[builtins fixtures/dataclasses.pyi]
[case testDataclassesForwardRefs]
from dataclasses import dataclass
@dataclass
class A:
b: 'B'
@dataclass
class B:
x: int
reveal_type(A) # N: Revealed type is "def (b: __main__.B) -> __main__.A"
A(b=B(42))
A(b=42) # E: Argument "b" to "A" has incompatible type "int"; expected "B"
[builtins fixtures/dataclasses.pyi]
[case testDataclassesInitVars]
from dataclasses import InitVar, dataclass
@dataclass
class Application:
name: str
database_name: InitVar[str]
reveal_type(Application) # N: Revealed type is "def (name: builtins.str, database_name: builtins.str) -> __main__.Application"
app = Application("example", 42) # E: Argument 2 to "Application" has incompatible type "int"; expected "str"
app = Application("example", "apps")
app.name
app.database_name # E: "Application" has no attribute "database_name"
@dataclass
class SpecializedApplication(Application):
rating: int
reveal_type(SpecializedApplication) # N: Revealed type is "def (name: builtins.str, database_name: builtins.str, rating: builtins.int) -> __main__.SpecializedApplication"
app = SpecializedApplication("example", "apps", "five") # E: Argument 3 to "SpecializedApplication" has incompatible type "str"; expected "int"
app = SpecializedApplication("example", "apps", 5)
app.name
app.rating
app.database_name # E: "SpecializedApplication" has no attribute "database_name"
[builtins fixtures/dataclasses.pyi]
[case testDataclassesInitVarsAndDefer]
from dataclasses import InitVar, dataclass
defer: Yes
@dataclass
class Application:
name: str
database_name: InitVar[str]
reveal_type(Application) # N: Revealed type is "def (name: builtins.str, database_name: builtins.str) -> __main__.Application"
app = Application("example", 42) # E: Argument 2 to "Application" has incompatible type "int"; expected "str"
app = Application("example", "apps")
app.name
app.database_name # E: "Application" has no attribute "database_name"
class Yes: ...
[builtins fixtures/dataclasses.pyi]
[case testDataclassesNoInitInitVarInheritance]
from dataclasses import dataclass, field, InitVar
@dataclass
class Super:
foo: InitVar = field(init=False)
@dataclass
class Sub(Super):
bar: int
sub = Sub(5)
sub.foo # E: "Sub" has no attribute "foo"
sub.bar
[builtins fixtures/dataclasses.pyi]
[case testDataclassFactory]
from typing import Type, TypeVar
from dataclasses import dataclass
T = TypeVar('T', bound='A')
@dataclass
class A:
@classmethod
def make(cls: Type[T]) -> T:
reveal_type(cls) # N: Revealed type is "type[T`-1]"
reveal_type(cls()) # N: Revealed type is "T`-1"
return cls()
[builtins fixtures/dataclasses.pyi]
[case testDataclassesInitVarOverride]
import dataclasses
@dataclasses.dataclass
class A:
a: dataclasses.InitVar[int]
_a: int = dataclasses.field(init=False)
def __post_init__(self, a):
self._a = a
@dataclasses.dataclass(init=False)
class B(A):
b: dataclasses.InitVar[int]
_b: int = dataclasses.field(init=False)
def __init__(self, b):
super().__init__(b+1)
self._b = b
[builtins fixtures/dataclasses.pyi]
[case testDataclassesInitVarNoOverride]
import dataclasses
@dataclasses.dataclass
class A:
a: dataclasses.InitVar[int]
_a: int = dataclasses.field(init=False)
def __post_init__(self, a):
self._a = a
@dataclasses.dataclass(init=True)
class B(A):
b: dataclasses.InitVar[int]
_b: int = dataclasses.field(init=False)
def __post_init__(self, a, b):
self._a = a
self._b = b
B(1, 2)
B(1, 'a') # E: Argument 2 to "B" has incompatible type "str"; expected "int"
[builtins fixtures/dataclasses.pyi]
[case testDataclassesInitVarPostInitOverride]
import dataclasses
@dataclasses.dataclass
class A:
a: dataclasses.InitVar[int]
_a: int = dataclasses.field(init=False)
def __post_init__(self, a: int) -> None:
self._a = a
@dataclasses.dataclass
class B(A):
b: int = dataclasses.field(init=False)
def __post_init__(self, a: int) -> None:
super().__post_init__(a)
self.b = a + 1
@dataclasses.dataclass(init=False)
class C(B):
c: int
def __init__(self, a: int, c: int) -> None:
super().__init__(a)
self.c = c + self.b
A(1)
B(1)
B(1, 2) # E: Too many arguments for "B"
C(1, 2)
C(1, 'a') # E: Argument 2 to "C" has incompatible type "str"; expected "int"
[builtins fixtures/primitives.pyi]
[case testDataclassesInitVarIncremental]
import a
[file a.py]
import dataclasses
from b import A
@dataclasses.dataclass
class B(A):
b: int = dataclasses.field(init=False)
def __post_init__(self, a: int) -> None:
super().__post_init__(a)
self.b = a + 1
[file a.py.2]
import dataclasses
from b import A
@dataclasses.dataclass
class B(A):
b: int = dataclasses.field(init=False)
def __post_init__(self, a: int) -> None:
super().__post_init__(a)
self.b = a + 2
reveal_type(B)
[file b.py]
import dataclasses
@dataclasses.dataclass
class A:
a: dataclasses.InitVar[int]
_a: int = dataclasses.field(init=False)
def __post_init__(self, a: int) -> None:
self._a = a
[out2]
tmp/a.py:12: note: Revealed type is "def (a: builtins.int) -> a.B"
[builtins fixtures/primitives.pyi]
[case testNoComplainFieldNone]
# flags: --no-strict-optional
from dataclasses import dataclass, field
from typing import Optional
@dataclass
class Foo:
bar: Optional[int] = field(default=None)
[builtins fixtures/dataclasses.pyi]
[out]
[case testNoComplainFieldNoneStrict]
from dataclasses import dataclass, field
from typing import Optional
@dataclass
class Foo:
bar: Optional[int] = field(default=None)
[builtins fixtures/dataclasses.pyi]
[out]
[case testDisallowUntypedWorksForward]
# flags: --disallow-untyped-defs
from dataclasses import dataclass
from typing import List
@dataclass
class B:
x: C
class C(List[C]):
pass
reveal_type(B) # N: Revealed type is "def (x: __main__.C) -> __main__.B"
[builtins fixtures/dataclasses.pyi]
[case testDisallowUntypedWorksForwardBad]
# flags: --disallow-untyped-defs
from dataclasses import dataclass
@dataclass
class B:
x: Undefined # E: Name "Undefined" is not defined
y = undefined() # E: Name "undefined" is not defined
reveal_type(B) # N: Revealed type is "def (x: Any) -> __main__.B"
[builtins fixtures/dataclasses.pyi]
[case testMemberExprWorksAsField]
import dataclasses
@dataclasses.dataclass
class A:
x: int = dataclasses.field(metadata={"doc": "foo"})
y: str
@dataclasses.dataclass
class B:
x: int = dataclasses.field(init=False, default=1)
y: str
@dataclasses.dataclass
class C:
x: int = dataclasses.field(default=1)
y: str = dataclasses.field(metadata={"doc": "foo"}) # E: Attributes without a default cannot follow attributes with one
[builtins fixtures/dict.pyi]
[case testDataclassOrderingDeferred]
from dataclasses import dataclass
defer: Yes
@dataclass(order=True)
class Application:
name: str
rating: int
a = Application('', 0)
b = Application('', 0)
a < b
class Yes: ...
[builtins fixtures/dataclasses.pyi]
[case testDataclassFieldDeferred]
from dataclasses import field, dataclass
@dataclass
class C:
x: int = field(default=func())
def func() -> int: ...
C('no') # E: Argument 1 to "C" has incompatible type "str"; expected "int"
[builtins fixtures/dataclasses.pyi]
[case testDataclassFieldDeferredFrozen]
from dataclasses import field, dataclass
@dataclass(frozen=True)
class C:
x: int = field(default=func())
def func() -> int: ...
c: C
c.x = 1 # E: Property "x" defined in "C" is read-only
[builtins fixtures/dataclasses.pyi]
[case testTypeInDataclassDeferredStar]
import lib
[file lib.py]
from dataclasses import dataclass
MYPY = False
if MYPY: # Force deferral
from other import *
@dataclass
class C:
total: int
C() # E: Missing positional argument "total" in call to "C"
C('no') # E: Argument 1 to "C" has incompatible type "str"; expected "int"
[file other.py]
import lib
[builtins fixtures/dataclasses.pyi]
[case testDeferredDataclassInitSignature]
# flags: --no-strict-optional
from dataclasses import dataclass
from typing import Optional, Type
@dataclass
class C:
x: Optional[int] = None
y: Type[Deferred] = Deferred
@classmethod
def default(cls) -> C:
return cls(x=None, y=None)
class Deferred: pass
[builtins fixtures/dataclasses.pyi]
[case testDeferredDataclassInitSignatureSubclass]
from dataclasses import dataclass
from typing import Optional
@dataclass
class B:
x: Optional[C]
@dataclass
class C(B):
y: str
a = C(None, 'abc')
[builtins fixtures/dataclasses.pyi]
[case testDataclassesDefaultsIncremental]
import a
[file a.py]
from dataclasses import dataclass
from b import Person
@dataclass
class Asdf(Person):
c: str = 'test'
[file a.py.2]
from dataclasses import dataclass
from b import Person
@dataclass
class Asdf(Person):
c: str = 'test'
# asdf
[file b.py]
from dataclasses import dataclass
@dataclass
class Person:
b: int
a: str = 'test'
[builtins fixtures/dataclasses.pyi]
[case testDataclassesFloatSerializationIncremental]
import m
[file m.py]
from lib import MyDataClass
[file m.py.2]
from lib import MyDataClass
reveal_type(MyDataClass.MY_CONSTANT)
[file lib.py]
from dataclasses import dataclass
from typing import Final
@dataclass(kw_only=True, repr=False)
class MyDataClass:
MY_CONSTANT: Final = 1.234
[builtins fixtures/dataclasses.pyi]
[out]
[out2]
tmp/m.py:3: note: Revealed type is "Literal[1.234]?"
[case testDataclassesDefaultsMroOtherFile]
import a
[file a.py]
from dataclasses import dataclass
from b import A1, A2
@dataclass
class Asdf(A1, A2): # E: Attributes without a default cannot follow attributes with one
pass
[file b.py]
from dataclasses import dataclass
# a bunch of blank lines to make sure the error doesn't accidentally line up...
@dataclass
class A1:
a: int
@dataclass
class A2:
b: str = 'test'
[builtins fixtures/dataclasses.pyi]
[case testDataclassesInheritingDuplicateField]
# see mypy issue #7792
from dataclasses import dataclass
@dataclass
class A:
x: int = 0
x: int = 0 # E: Name "x" already defined on line 6
@dataclass
class B(A):
pass
[builtins fixtures/dataclasses.pyi]
[case testDataclassInheritanceNoAnnotation]
from dataclasses import dataclass
@dataclass
class A:
foo: int
x = 0
@dataclass
class B(A):
foo = x
reveal_type(B) # N: Revealed type is "def (foo: builtins.int) -> __main__.B"
[builtins fixtures/dataclasses.pyi]
[case testDataclassInheritanceNoAnnotation2]
from dataclasses import dataclass
@dataclass(frozen=True)
class A:
foo: int
@dataclass(frozen=True)
class B(A):
@property # E: Dataclass attribute may only be overridden by another attribute
def foo(self) -> int: pass
reveal_type(B) # N: Revealed type is "def (foo: builtins.int) -> __main__.B"
[builtins fixtures/dataclasses.pyi]
[case testDataclassHasAttributeWithFields]
from dataclasses import dataclass
@dataclass
class A:
pass
reveal_type(A.__dataclass_fields__) # N: Revealed type is "builtins.dict[builtins.str, dataclasses.Field[Any]]"
[builtins fixtures/dict.pyi]
[case testDataclassCallableFieldAccess]
from dataclasses import dataclass
from typing import Callable
@dataclass
class A:
x: Callable[[int], int]
y: Callable[[int], int] = lambda i: i
a = A(lambda i:i)
x: int = a.x(0)
y: str = a.y(0) # E: Incompatible types in assignment (expression has type "int", variable has type "str")
reveal_type(a.x) # N: Revealed type is "def (builtins.int) -> builtins.int"
reveal_type(a.y) # N: Revealed type is "def (builtins.int) -> builtins.int"
reveal_type(A.y) # N: Revealed type is "def (builtins.int) -> builtins.int"
[builtins fixtures/dataclasses.pyi]
[case testDataclassCallableFieldAssignment]
from dataclasses import dataclass
from typing import Callable
@dataclass
class A:
x: Callable[[int], int]
def x(i: int) -> int:
return i
def x2(s: str) -> str:
return s
a = A(lambda i:i)
a.x = x
a.x = x2 # E: Incompatible types in assignment (expression has type "Callable[[str], str]", variable has type "Callable[[int], int]")
[builtins fixtures/dataclasses.pyi]
[case testDataclassFieldDoesNotFailOnKwargsUnpacking]
# https://github.com/python/mypy/issues/10879
from dataclasses import dataclass, field
@dataclass
class Foo:
bar: float = field(**{"repr": False})
[out]
main:6: error: Unpacking **kwargs in "field()" is not supported
main:6: error: No overload variant of "field" matches argument type "dict[str, bool]"
main:6: note: Possible overload variants:
main:6: note: def [_T] field(*, default: _T, init: bool = ..., repr: bool = ..., hash: bool | None = ..., compare: bool = ..., metadata: Mapping[str, Any] | None = ..., kw_only: bool = ...) -> _T
main:6: note: def [_T] field(*, default_factory: Callable[[], _T], init: bool = ..., repr: bool = ..., hash: bool | None = ..., compare: bool = ..., metadata: Mapping[str, Any] | None = ..., kw_only: bool = ...) -> _T
main:6: note: def field(*, init: bool = ..., repr: bool = ..., hash: bool | None = ..., compare: bool = ..., metadata: Mapping[str, Any] | None = ..., kw_only: bool = ...) -> Any
[builtins fixtures/dataclasses.pyi]
[case testDataclassFieldWithPositionalArguments]
from dataclasses import dataclass, field
@dataclass
class C:
x: int = field(0) # E: "field()" does not accept positional arguments \
# E: No overload variant of "field" matches argument type "int" \
# N: Possible overload variants: \
# N: def [_T] field(*, default: _T, init: bool = ..., repr: bool = ..., hash: bool | None = ..., compare: bool = ..., metadata: Mapping[str, Any] | None = ..., kw_only: bool = ...) -> _T \
# N: def [_T] field(*, default_factory: Callable[[], _T], init: bool = ..., repr: bool = ..., hash: bool | None = ..., compare: bool = ..., metadata: Mapping[str, Any] | None = ..., kw_only: bool = ...) -> _T \
# N: def field(*, init: bool = ..., repr: bool = ..., hash: bool | None = ..., compare: bool = ..., metadata: Mapping[str, Any] | None = ..., kw_only: bool = ...) -> Any
[builtins fixtures/dataclasses.pyi]
[case testDataclassFieldWithTypedDictUnpacking]
from dataclasses import dataclass, field
from typing import TypedDict
class FieldKwargs(TypedDict):
repr: bool
field_kwargs: FieldKwargs = {"repr": False}
@dataclass
class Foo:
bar: float = field(**field_kwargs) # E: Unpacking **kwargs in "field()" is not supported
reveal_type(Foo(bar=1.5)) # N: Revealed type is "__main__.Foo"
[builtins fixtures/dataclasses.pyi]
[typing fixtures/typing-typeddict.pyi]
[case testDataclassWithSlotsArg]
from dataclasses import dataclass
@dataclass(slots=True)
class Some:
x: int
def __init__(self, x: int) -> None:
self.x = x
self.y = 0 # E: Trying to assign name "y" that is not in "__slots__" of type "__main__.Some"
def __post_init__(self) -> None:
self.y = 1 # E: Trying to assign name "y" that is not in "__slots__" of type "__main__.Some"
[builtins fixtures/dataclasses.pyi]
[case testDataclassWithSlotsDef]
from dataclasses import dataclass
@dataclass(slots=False)
class Some:
__slots__ = ('x',)
x: int
def __init__(self, x: int) -> None:
self.x = x
self.y = 0 # E: Trying to assign name "y" that is not in "__slots__" of type "__main__.Some"
def __post_init__(self) -> None:
self.y = 1 # E: Trying to assign name "y" that is not in "__slots__" of type "__main__.Some"
[builtins fixtures/dataclasses.pyi]
[case testDataclassWithSlotsDerivedFromNonSlot]
from dataclasses import dataclass
class A:
pass
@dataclass(slots=True)
class B(A):
x: int
def __post_init__(self) -> None:
self.y = 42
[builtins fixtures/dataclasses.pyi]
[case testDataclassWithSlotsConflict]
from dataclasses import dataclass
@dataclass(slots=True)
class Some: # E: "Some" both defines "__slots__" and is used with "slots=True"
__slots__ = ('x',)
x: int
@dataclass(slots=True)
class EmptyDef: # E: "EmptyDef" both defines "__slots__" and is used with "slots=True"
__slots__ = ()
x: int
slots = ('x',)
@dataclass(slots=True)
class DynamicDef: # E: "DynamicDef" both defines "__slots__" and is used with "slots=True"
__slots__ = slots
x: int
[builtins fixtures/dataclasses.pyi]
[case testDataclassWithSlotsRuntimeAttr]
from dataclasses import dataclass
@dataclass(slots=True)
class Some:
x: int
y: str
z: bool
reveal_type(Some.__slots__) # N: Revealed type is "tuple[builtins.str, builtins.str, builtins.str]"
@dataclass(slots=True)
class Other:
x: int
y: str
reveal_type(Other.__slots__) # N: Revealed type is "tuple[builtins.str, builtins.str]"
@dataclass
class NoSlots:
x: int
y: str
NoSlots.__slots__ # E: "type[NoSlots]" has no attribute "__slots__"
[builtins fixtures/dataclasses.pyi]
[case testSlotsDefinitionWithTwoPasses1]
# https://github.com/python/mypy/issues/11821
from typing import TypeVar, Protocol, Generic
from dataclasses import dataclass
C = TypeVar("C", bound="Comparable")
class Comparable(Protocol):
pass
V = TypeVar("V", bound=Comparable)
@dataclass(slots=True)
class Node(Generic[V]): # Error was here
data: V
[builtins fixtures/dataclasses.pyi]
[case testSlotsDefinitionWithTwoPasses2]
from typing import TypeVar, Protocol, Generic
from dataclasses import dataclass
C = TypeVar("C", bound="Comparable")
class Comparable(Protocol):
pass
V = TypeVar("V", bound=Comparable)
@dataclass(slots=True) # Explicit slots are still not ok:
class Node(Generic[V]): # E: "Node" both defines "__slots__" and is used with "slots=True"
__slots__ = ('data',)
data: V
[builtins fixtures/dataclasses.pyi]
[case testSlotsDefinitionWithTwoPasses3]
from typing import TypeVar, Protocol, Generic
from dataclasses import dataclass
C = TypeVar("C", bound="Comparable")
class Comparable(Protocol):
pass
V = TypeVar("V", bound=Comparable)
@dataclass(slots=True) # Explicit slots are still not ok, even empty ones:
class Node(Generic[V]): # E: "Node" both defines "__slots__" and is used with "slots=True"
__slots__ = ()
data: V
[builtins fixtures/dataclasses.pyi]
[case testSlotsDefinitionWithTwoPasses4]
import dataclasses as dtc
PublishedMessagesVar = dict[int, 'PublishedMessages']
@dtc.dataclass(frozen=True, slots=True)
class PublishedMessages:
left: int
[builtins fixtures/dataclasses.pyi]
[case testDataclassSlotsWithDeferredBase]
from dataclasses import dataclass
@dataclass
class A(B): ...
@dataclass
class B: ...
@dataclass(slots=True)
class C: ...
[builtins fixtures/dataclasses.pyi]
[case testDataclassesAnyInherit]
from dataclasses import dataclass
from typing import Any
B: Any
@dataclass
class A(B):
a: int
@dataclass
class C(B):
generated_args: int
generated_kwargs: int
A(a=1, b=2)
A(1)
A(a="foo") # E: Argument "a" to "A" has incompatible type "str"; expected "int"
C(generated_args="foo", generated_kwargs="bar") # E: Argument "generated_args" to "C" has incompatible type "str"; expected "int" \
# E: Argument "generated_kwargs" to "C" has incompatible type "str"; expected "int"
[builtins fixtures/dataclasses.pyi]
[case testDataclassesCallableFrozen]
from dataclasses import dataclass
from typing import Any, Callable
@dataclass(frozen=True)
class A:
a: Callable[..., None]
def func() -> None:
pass
reveal_type(A.a) # N: Revealed type is "def (*Any, **Any)"
A(a=func).a()
A(a=func).a = func # E: Property "a" defined in "A" is read-only
[builtins fixtures/dataclasses.pyi]
[case testDataclassesCallableFrozenOverride]
from dataclasses import dataclass
from typing import Callable
@dataclass(frozen=True)
class A:
a: Callable[[int], str] = lambda x: "yes"
def foo(x: int) -> str:
return "no"
@dataclass(frozen=True)
class Sub(A):
# This is no-op for attribute access on instances,
# so we effectively check the subtyping as if accessed on class.
a = foo
[builtins fixtures/dataclasses.pyi]
[case testDataclassesCallableFrozenSelf]
from dataclasses import dataclass
from typing import Self, Callable
@dataclass(frozen=True)
class A:
a: Callable[[Self], str]
a: A
reveal_type(a.a) # N: Revealed type is "def (__main__.A) -> builtins.str"
[builtins fixtures/dataclasses.pyi]
[case testDataclassInFunctionDoesNotCrash]
from dataclasses import dataclass
def foo() -> None:
@dataclass
class Foo:
foo: int
# This used to crash (see #8703)
# The return type of __call__ here needs to be something undefined
# In order to trigger the crash that existed prior to #12762
def __call__(self) -> asdf: ... # E: Name "asdf" is not defined
[builtins fixtures/dataclasses.pyi]
[case testDataclassesMultipleInheritanceWithNonDataclass]
from dataclasses import dataclass
@dataclass
class A:
prop_a: str
@dataclass
class B:
prop_b: bool
class Derived(A, B):
pass
[builtins fixtures/dataclasses.pyi]
[case testDataclassGenericInheritance2]
from dataclasses import dataclass
from typing import Any, Callable, Generic, TypeVar, List
T = TypeVar("T")
S = TypeVar("S")
@dataclass
class Parent(Generic[T]):
f: Callable[[T], Any]
@dataclass
class Child(Parent[T]): ...
class A: ...
def func(obj: A) -> bool: ...
reveal_type(Child[A](func).f) # N: Revealed type is "def (__main__.A) -> Any"
@dataclass
class Parent2(Generic[T]):
a: List[T]
@dataclass
class Child2(Generic[T, S], Parent2[S]):
b: List[T]
reveal_type(Child2([A()], [1]).a) # N: Revealed type is "builtins.list[__main__.A]"
reveal_type(Child2[int, A]([A()], [1]).b) # N: Revealed type is "builtins.list[builtins.int]"
[builtins fixtures/dataclasses.pyi]
[case testDataclassInheritOptionalType]
from dataclasses import dataclass
from typing import Any, Callable, Generic, TypeVar, List, Optional
T = TypeVar("T")
@dataclass
class Parent(Generic[T]):
x: Optional[str]
@dataclass
class Child(Parent):
y: Optional[int]
Child(x=1, y=1) # E: Argument "x" to "Child" has incompatible type "int"; expected "str | None"
Child(x='', y='') # E: Argument "y" to "Child" has incompatible type "str"; expected "int | None"
Child(x='', y=1)
Child(x=None, y=None)
[builtins fixtures/dataclasses.pyi]
[case testDataclassGenericInheritanceSpecialCase1]
from dataclasses import dataclass
from typing import Generic, TypeVar, List
T = TypeVar("T")
@dataclass
class Parent(Generic[T]):
x: List[T]
@dataclass
class Child1(Parent["Child2"]): ...
@dataclass
class Child2(Parent["Child1"]): ...
def f(c: Child2) -> None:
reveal_type(Child1([c]).x) # N: Revealed type is "builtins.list[__main__.Child2]"
def g(c: Child1) -> None:
reveal_type(Child2([c]).x) # N: Revealed type is "builtins.list[__main__.Child1]"
[builtins fixtures/dataclasses.pyi]
[case testDataclassGenericInheritanceSpecialCase2]
from dataclasses import dataclass
from typing import Generic, TypeVar
T = TypeVar("T")
# A subclass might be analyzed before base in import cycles. They are
# defined here in reversed order to simulate this.
@dataclass
class Child1(Parent["Child2"]):
x: int
@dataclass
class Child2(Parent["Child1"]):
y: int
@dataclass
class Parent(Generic[T]):
key: str
Child1(x=1, key='')
Child2(y=1, key='')
[builtins fixtures/dataclasses.pyi]
[case testDataclassGenericWithBound]
from dataclasses import dataclass
from typing import Generic, TypeVar
T = TypeVar("T", bound="C")
@dataclass
class C(Generic[T]):
x: int
c: C[C]
d: C[str] # E: Type argument "str" of "C" must be a subtype of "C[Any]"
C(x=2)
[builtins fixtures/dataclasses.pyi]
[case testDataclassGenericBoundToInvalidTypeVarDoesNotCrash]
import dataclasses
from typing import Generic, TypeVar
T = TypeVar("T", bound="NotDefined") # E: Name "NotDefined" is not defined
@dataclasses.dataclass
class C(Generic[T]):
x: float
[builtins fixtures/dataclasses.pyi]
[case testDataclassInitVarCannotBeSet]
from dataclasses import dataclass, InitVar
@dataclass
class C:
x: InitVar[int] = 0
y: InitVar[str] = ''
def f(self) -> None:
# This works at runtime, but it seems like an abuse of the InitVar
# feature and thus we don't support it
self.x = 1 # E: "C" has no attribute "x"
self.y: str = 'x' # E: "C" has no attribute "y"
c = C()
c2 = C(x=1)
c.x # E: "C" has no attribute "x"
[builtins fixtures/dataclasses.pyi]
[case testDataclassCheckTypeVarBounds]
from dataclasses import dataclass
from typing import ClassVar, Protocol, Dict, TypeVar, Generic
class DataclassProtocol(Protocol):
__dataclass_fields__: ClassVar[Dict]
T = TypeVar("T", bound=DataclassProtocol)
@dataclass
class MyDataclass:
x: int = 1
class MyGeneric(Generic[T]): ...
class MyClass(MyGeneric[MyDataclass]): ...
[builtins fixtures/dataclasses.pyi]
[case testDataclassWithMatchArgs]
from dataclasses import dataclass
@dataclass
class One:
bar: int
baz: str
o: One
reveal_type(o.__match_args__) # N: Revealed type is "tuple[Literal['bar'], Literal['baz']]"
@dataclass(match_args=True)
class Two:
bar: int
t: Two
reveal_type(t.__match_args__) # N: Revealed type is "tuple[Literal['bar']]"
@dataclass
class Empty:
...
e: Empty
reveal_type(e.__match_args__) # N: Revealed type is "tuple[()]"
[builtins fixtures/dataclasses.pyi]
[case testDataclassWithMatchArgsAndKwOnly]
from dataclasses import dataclass, field
@dataclass(kw_only=True)
class One:
a: int
b: str
reveal_type(One.__match_args__) # N: Revealed type is "tuple[()]"
@dataclass(kw_only=True)
class Two:
a: int = field(kw_only=False)
b: str
reveal_type(Two.__match_args__) # N: Revealed type is "tuple[Literal['a']]"
[builtins fixtures/dataclasses.pyi]
[case testDataclassWithoutMatchArgs]
from dataclasses import dataclass
@dataclass(match_args=False)
class One:
bar: int
baz: str
o: One
reveal_type(o.__match_args__) # E: "One" has no attribute "__match_args__" \
# N: Revealed type is "Any"
[builtins fixtures/dataclasses.pyi]
[case testFinalInDataclass]
from dataclasses import dataclass
from typing import Final
@dataclass
class FirstClass:
FIRST_CONST: Final = 3 # OK
@dataclass
class SecondClass:
SECOND_CONST: Final = FirstClass.FIRST_CONST # E: Need type argument for Final[...] with non-literal default in dataclass
reveal_type(FirstClass().FIRST_CONST) # N: Revealed type is "Literal[3]?"
FirstClass().FIRST_CONST = 42 # E: Cannot assign to final attribute "FIRST_CONST"
reveal_type(SecondClass().SECOND_CONST) # N: Revealed type is "Literal[3]?"
SecondClass().SECOND_CONST = 42 # E: Cannot assign to final attribute "SECOND_CONST"
[builtins fixtures/dataclasses.pyi]
[case testDataclassFieldsProtocol]
from dataclasses import dataclass
from typing import Any, Protocol
class ConfigProtocol(Protocol):
__dataclass_fields__: dict[str, Any]
def takes_cp(cp: ConfigProtocol): ...
@dataclass
class MyDataclass:
x: int = 3
takes_cp(MyDataclass)
[builtins fixtures/dataclasses.pyi]
[case testDataclassTypeAnnotationAliasUpdated]
import a
[file a.py]
from dataclasses import dataclass
from b import B
@dataclass
class D:
x: B
reveal_type(D) # N: Revealed type is "def (x: builtins.list[b.C]) -> a.D"
[file b.py]
from typing import List
import a
class CC: ...
class C(CC): ...
B = List[C]
[builtins fixtures/dataclasses.pyi]
[case testDataclassSelfType]
from dataclasses import dataclass
from typing import Self, TypeVar, Generic, Optional
T = TypeVar("T")
@dataclass
class LinkedList(Generic[T]):
value: T
next: Optional[Self] = None
def meth(self) -> None:
reveal_type(self.next) # N: Revealed type is "Self`0 | None"
l_int: LinkedList[int] = LinkedList(1, LinkedList("no", None)) # E: Argument 1 to "LinkedList" has incompatible type "str"; expected "int"
@dataclass
class SubLinkedList(LinkedList[int]): ...
lst = SubLinkedList(1, LinkedList(2)) # E: Argument 2 to "SubLinkedList" has incompatible type "LinkedList[int]"; expected "SubLinkedList | None"
reveal_type(lst.next) # N: Revealed type is "__main__.SubLinkedList | None"
reveal_type(SubLinkedList) # N: Revealed type is "def (value: builtins.int, next: __main__.SubLinkedList | None =) -> __main__.SubLinkedList"
[builtins fixtures/dataclasses.pyi]
[case testNoCrashOnNestedGenericCallable]
from dataclasses import dataclass
from typing import Generic, TypeVar, Callable
T = TypeVar('T')
R = TypeVar('R')
X = TypeVar('X')
@dataclass
class Box(Generic[T]):
inner: T
@dataclass
class Cont(Generic[R]):
run: Box[Callable[[X], R]]
def const_two(x: T) -> str:
return "two"
c = Cont(Box(const_two))
reveal_type(c) # N: Revealed type is "__main__.Cont[builtins.str]"
[builtins fixtures/dataclasses.pyi]
[case testNoCrashOnSelfWithForwardRefGenericDataclass]
from typing import Generic, Sequence, TypeVar, Self
from dataclasses import dataclass
_T = TypeVar('_T', bound="Foo")
@dataclass
class Foo:
foo: int
@dataclass
class Element(Generic[_T]):
elements: Sequence[Self]
@dataclass
class Bar(Foo): ...
e: Element[Bar]
reveal_type(e.elements) # N: Revealed type is "typing.Sequence[__main__.Element[__main__.Bar]]"
[builtins fixtures/dataclasses.pyi]
[case testIfConditionsInDefinition]
# flags: --python-version 3.11 --always-true TRUTH
from dataclasses import dataclass
from typing import TYPE_CHECKING
TRUTH = False # Is set to --always-true
@dataclass
class Foo:
if TYPE_CHECKING:
present_1: int
else:
skipped_1: int
if True: # Mypy does not know if it is True or False, so the block is used
present_2: int
if False: # Mypy does not know if it is True or False, so the block is used
present_3: int
if not TRUTH:
skipped_2: int
elif 123:
present_4: int
elif TRUTH:
present_5: int
else:
skipped_3: int
Foo(
present_1=1,
present_2=2,
present_3=3,
present_4=4,
present_5=5,
)
[builtins fixtures/dataclasses.pyi]
[case testReplace]
from dataclasses import dataclass, replace, InitVar
from typing import ClassVar
@dataclass
class A:
x: int
q: InitVar[int]
q2: InitVar[int] = 0
c: ClassVar[int]
a = A(x=42, q=7)
a2 = replace(a) # E: Missing named argument "q" for "replace" of "A"
a2 = replace(a, q=42)
a2 = replace(a, x=42, q=42)
a2 = replace(a, x=42, q=42, c=7) # E: Unexpected keyword argument "c" for "replace" of "A"
a2 = replace(a, x='42', q=42) # E: Argument "x" to "replace" of "A" has incompatible type "str"; expected "int"
a2 = replace(a, q='42') # E: Argument "q" to "replace" of "A" has incompatible type "str"; expected "int"
reveal_type(a2) # N: Revealed type is "__main__.A"
[builtins fixtures/tuple.pyi]
[case testReplaceUnion]
from typing import Generic, Union, TypeVar
from dataclasses import dataclass, replace, InitVar
T = TypeVar('T')
@dataclass
class A(Generic[T]):
x: T # exercises meet(T=int, int) = int
y: bool # exercises meet(bool, int) = bool
z: str # exercises meet(str, bytes) = Never
w: dict # exercises meet(dict, Never) = Never
init_var: InitVar[int] # exercises (non-optional, optional) = non-optional
@dataclass
class B:
x: int
y: int
z: bytes
init_var: int
a_or_b: Union[A[int], B]
_ = replace(a_or_b, x=42, y=True, init_var=42)
_ = replace(a_or_b, x=42, y=True) # E: Missing named argument "init_var" for "replace" of "A[int] | B"
_ = replace(a_or_b, x=42, y=True, z='42', init_var=42) # E: Argument "z" to "replace" of "A[int] | B" has incompatible type "str"; expected "Never"
_ = replace(a_or_b, x=42, y=True, w={}, init_var=42) # E: Argument "w" to "replace" of "A[int] | B" has incompatible type "dict[Never, Never]"; expected "Never"
_ = replace(a_or_b, y=42, init_var=42) # E: Argument "y" to "replace" of "A[int] | B" has incompatible type "int"; expected "bool"
[builtins fixtures/tuple.pyi]
[case testReplaceUnionOfTypeVar]
from typing import Generic, Union, TypeVar
from dataclasses import dataclass, replace
@dataclass
class A:
x: int
y: int
z: str
w: dict
class B:
pass
TA = TypeVar('TA', bound=A)
TB = TypeVar('TB', bound=B)
def f(b_or_t: Union[TA, TB, int]) -> None:
a2 = replace(b_or_t) # E: Value of type variable "_DataclassT" of "replace" cannot be "TA | TB | int"
[builtins fixtures/tuple.pyi]
[case testReplaceTypeVarBoundNotDataclass]
from dataclasses import dataclass, replace
from typing import Union, TypeVar
TInt = TypeVar('TInt', bound=int)
TAny = TypeVar('TAny')
TNone = TypeVar('TNone', bound=None)
TUnion = TypeVar('TUnion', bound=Union[str, int])
def f1(t: TInt) -> None:
_ = replace(t, x=42) # E: Value of type variable "_DataclassT" of "replace" cannot be "TInt"
def f2(t: TAny) -> TAny:
return replace(t, x='spam') # E: Value of type variable "_DataclassT" of "replace" cannot be "TAny"
def f3(t: TNone) -> TNone:
return replace(t, x='spam') # E: Value of type variable "_DataclassT" of "replace" cannot be "TNone"
def f4(t: TUnion) -> TUnion:
return replace(t, x='spam') # E: Value of type variable "_DataclassT" of "replace" cannot be "TUnion"
[builtins fixtures/tuple.pyi]
[case testReplaceTypeVarBound]
from dataclasses import dataclass, replace
from typing import TypeVar
@dataclass
class A:
x: int
@dataclass
class B(A):
pass
TA = TypeVar('TA', bound=A)
def f(t: TA) -> TA:
t2 = replace(t, x=42)
reveal_type(t2) # N: Revealed type is "TA`-1"
_ = replace(t, x='42') # E: Argument "x" to "replace" of "TA" has incompatible type "str"; expected "int"
return t2
f(A(x=42))
f(B(x=42))
[builtins fixtures/tuple.pyi]
[case testReplaceAny]
from dataclasses import replace
from typing import Any
a: Any
a2 = replace(a)
reveal_type(a2) # N: Revealed type is "Any"
[builtins fixtures/tuple.pyi]
[case testReplaceNotDataclass]
from dataclasses import replace
replace(5) # E: Value of type variable "_DataclassT" of "replace" cannot be "int"
class C:
pass
replace(C()) # E: Value of type variable "_DataclassT" of "replace" cannot be "C"
replace(None) # E: Value of type variable "_DataclassT" of "replace" cannot be "None"
[builtins fixtures/tuple.pyi]
[case testReplaceIsDataclass]
from dataclasses import is_dataclass, replace
def f(x: object) -> None:
_ = replace(x) # E: Value of type variable "_DataclassT" of "replace" cannot be "object"
if is_dataclass(x):
_ = replace(x) # E: Value of type variable "_DataclassT" of "replace" cannot be "DataclassInstance | type[DataclassInstance]"
if not isinstance(x, type):
_ = replace(x)
[builtins fixtures/tuple.pyi]
[case testReplaceGeneric]
from dataclasses import dataclass, replace, InitVar
from typing import ClassVar, Generic, TypeVar
T = TypeVar('T')
@dataclass
class A(Generic[T]):
x: T
a = A(x=42)
reveal_type(a) # N: Revealed type is "__main__.A[builtins.int]"
a2 = replace(a, x=42)
reveal_type(a2) # N: Revealed type is "__main__.A[builtins.int]"
a2 = replace(a, x='42') # E: Argument "x" to "replace" of "A[int]" has incompatible type "str"; expected "int"
reveal_type(a2) # N: Revealed type is "__main__.A[builtins.int]"
[builtins fixtures/tuple.pyi]
[case testPostInitNotMethod]
def __post_init__() -> None:
pass
[case testPostInitCorrectSignature]
from typing import Any, Generic, TypeVar, Callable, Self
from dataclasses import dataclass, InitVar
@dataclass
class Test1:
x: int
def __post_init__(self) -> None: ...
@dataclass
class Test2:
x: int
y: InitVar[int]
z: str
def __post_init__(self, y: int) -> None: ...
@dataclass
class Test3:
x: InitVar[int]
y: InitVar[str]
def __post_init__(self, x: int, y: str) -> None: ...
@dataclass
class Test4:
x: int
y: InitVar[str]
z: InitVar[bool] = True
def __post_init__(self, y: str, z: bool) -> None: ...
@dataclass
class Test5:
y: InitVar[str] = 'a'
z: InitVar[bool] = True
def __post_init__(self, y: str = 'a', z: bool = True) -> None: ...
F = TypeVar('F', bound=Callable[..., Any])
def identity(f: F) -> F: return f
@dataclass
class Test6:
y: InitVar[str]
@identity # decorated method works
def __post_init__(self, y: str) -> None: ...
T = TypeVar('T')
@dataclass
class Test7(Generic[T]):
t: InitVar[T]
def __post_init__(self, t: T) -> None: ...
@dataclass
class Test8:
s: InitVar[Self]
def __post_init__(self, s: Self) -> None: ...
[builtins fixtures/dataclasses.pyi]
[case testPostInitSubclassing]
from dataclasses import dataclass, InitVar
@dataclass
class Base:
a: str
x: InitVar[int]
def __post_init__(self, x: int) -> None: ...
@dataclass
class Child(Base):
b: str
y: InitVar[str]
def __post_init__(self, x: int, y: str) -> None: ...
@dataclass
class GrandChild(Child):
c: int
z: InitVar[str] = "a"
def __post_init__(self, x: int, y: str, z: str) -> None: ...
[builtins fixtures/dataclasses.pyi]
[case testPostInitNotADataclassCheck]
from dataclasses import dataclass, InitVar
class Regular:
__post_init__ = 1 # can be whatever
class Base:
x: InitVar[int]
def __post_init__(self) -> None: ... # can be whatever
@dataclass
class Child(Base):
y: InitVar[str]
def __post_init__(self, y: str) -> None: ...
[builtins fixtures/dataclasses.pyi]
[case testPostInitMissingParam]
from dataclasses import dataclass, InitVar
@dataclass
class Child:
y: InitVar[str]
def __post_init__(self) -> None: ...
[builtins fixtures/dataclasses.pyi]
[out]
main:6: error: Signature of "__post_init__" incompatible with supertype "dataclass"
main:6: note: Superclass:
main:6: note: def __post_init__(self: Child, y: str) -> None
main:6: note: Subclass:
main:6: note: def __post_init__(self: Child) -> None
[case testPostInitWrongTypeAndName]
from dataclasses import dataclass, InitVar
@dataclass
class Test1:
y: InitVar[str]
def __post_init__(self, x: int) -> None: ... # E: Argument 2 of "__post_init__" is incompatible with supertype "dataclass"; supertype defines the argument type as "str"
@dataclass
class Test2:
y: InitVar[str] = 'a'
def __post_init__(self, x: int) -> None: ... # E: Argument 2 of "__post_init__" is incompatible with supertype "dataclass"; supertype defines the argument type as "str"
[builtins fixtures/dataclasses.pyi]
[case testPostInitExtraParam]
from dataclasses import dataclass, InitVar
@dataclass
class Child:
y: InitVar[str]
def __post_init__(self, y: str, z: int) -> None: ...
[builtins fixtures/dataclasses.pyi]
[out]
main:6: error: Signature of "__post_init__" incompatible with supertype "dataclass"
main:6: note: Superclass:
main:6: note: def __post_init__(self: Child, y: str) -> None
main:6: note: Subclass:
main:6: note: def __post_init__(self: Child, y: str, z: int) -> None
[case testPostInitReturnType]
from dataclasses import dataclass, InitVar
@dataclass
class Child:
y: InitVar[str]
def __post_init__(self, y: str) -> int: ... # E: Return type "int" of "__post_init__" incompatible with return type "None" in supertype "dataclass"
[builtins fixtures/dataclasses.pyi]
[case testPostInitDecoratedMethodError]
from dataclasses import dataclass, InitVar
from typing import Any, Callable, TypeVar
F = TypeVar('F', bound=Callable[..., Any])
def identity(f: F) -> F: return f
@dataclass
class Klass:
y: InitVar[str]
@identity
def __post_init__(self) -> None: ...
[builtins fixtures/dataclasses.pyi]
[out]
main:11: error: Signature of "__post_init__" incompatible with supertype "dataclass"
main:11: note: Superclass:
main:11: note: def __post_init__(self: Klass, y: str) -> None
main:11: note: Subclass:
main:11: note: def __post_init__(self: Klass) -> None
[case testPostInitIsNotAFunction]
from dataclasses import dataclass, InitVar
@dataclass
class Test:
y: InitVar[str]
__post_init__ = 1 # E: "__post_init__" method must be an instance method
[builtins fixtures/dataclasses.pyi]
[case testPostInitClassMethod]
from dataclasses import dataclass, InitVar
@dataclass
class Test:
y: InitVar[str]
@classmethod
def __post_init__(cls) -> None: ...
[builtins fixtures/dataclasses.pyi]
[out]
main:7: error: Signature of "__post_init__" incompatible with supertype "dataclass"
main:7: note: Superclass:
main:7: note: def __post_init__(self: Test, y: str) -> None
main:7: note: Subclass:
main:7: note: @classmethod
main:7: note: def __post_init__(cls: type[Test]) -> None
[case testPostInitStaticMethod]
from dataclasses import dataclass, InitVar
@dataclass
class Test:
y: InitVar[str]
@staticmethod
def __post_init__() -> None: ...
[builtins fixtures/dataclasses.pyi]
[out]
main:7: error: Signature of "__post_init__" incompatible with supertype "dataclass"
main:7: note: Superclass:
main:7: note: def __post_init__(self: Test, y: str) -> None
main:7: note: Subclass:
main:7: note: @staticmethod
main:7: note: def __post_init__() -> None
[case testProtocolNoCrash]
from typing import Protocol, Union, ClassVar
from dataclasses import dataclass, field
DEFAULT = 0
@dataclass
class Test(Protocol):
x: int
def reset(self) -> None:
self.x = DEFAULT
[builtins fixtures/dataclasses.pyi]
[case testProtocolNoCrashOnJoining]
from dataclasses import dataclass
from typing import Protocol
@dataclass
class MyDataclass(Protocol): ...
a: MyDataclass
b = [a, a] # trigger joining the types
[builtins fixtures/dataclasses.pyi]
[case testPropertyAndFieldRedefinitionNoCrash]
from dataclasses import dataclass
@dataclass
class Foo:
@property
def c(self) -> int:
return 0
c: int # E: Name "c" already defined on line 5
[builtins fixtures/dataclasses.pyi]
[case testDataclassInheritanceWorksWithExplicitOverrides]
# flags: --enable-error-code explicit-override
from dataclasses import dataclass
@dataclass
class Base:
x: int
@dataclass
class Child(Base):
y: int
[builtins fixtures/dataclasses.pyi]
[case testDataclassesInitVarsWithProperty]
from dataclasses import InitVar, dataclass, field
@dataclass
class Test:
foo: InitVar[str]
_foo: str = field(init=False)
def __post_init__(self, foo: str) -> None:
self._foo = foo
@property
def foo(self) -> str:
return self._foo
@foo.setter
def foo(self, value: str) -> None:
self._foo = value
reveal_type(Test) # N: Revealed type is "def (foo: builtins.str) -> __main__.Test"
test = Test(42) # E: Argument 1 to "Test" has incompatible type "int"; expected "str"
test = Test("foo")
test.foo
[builtins fixtures/dataclasses.pyi]
[case testDataclassesDefaultValueInitVarWithProperty]
from dataclasses import InitVar, dataclass, field
@dataclass
class Test:
foo: InitVar[str] = "foo"
_foo: str = field(init=False)
def __post_init__(self, foo: str) -> None:
self._foo = foo
@property # E: InitVar with default value cannot be redefined
def foo(self) -> str:
return self._foo
[builtins fixtures/dataclasses.pyi]
[case testDataclassesWithProperty]
from dataclasses import dataclass
@dataclass
class Test:
@property
def foo(self) -> str:
return "a"
@foo.setter
def foo(self, value: str) -> None:
pass
[builtins fixtures/dataclasses.pyi]
[case testDataclassInheritanceWorksWithExplicitOverridesAndOrdering]
# flags: --enable-error-code explicit-override
from dataclasses import dataclass
@dataclass(order=True)
class Base:
x: int
@dataclass(order=True)
class Child(Base):
y: int
[builtins fixtures/dataclasses.pyi]
[case testDunderReplacePresent]
# flags: --python-version 3.13
from dataclasses import dataclass, field
@dataclass
class Coords:
x: int
y: int
# non-init fields are not allowed with replace:
z: int = field(init=False)
replaced = Coords(2, 4).__replace__(x=2, y=5)
reveal_type(replaced) # N: Revealed type is "__main__.Coords"
replaced = Coords(2, 4).__replace__(x=2)
reveal_type(replaced) # N: Revealed type is "__main__.Coords"
Coords(2, 4).__replace__(x="asdf") # E: Argument "x" to "__replace__" of "Coords" has incompatible type "str"; expected "int"
Coords(2, 4).__replace__(23) # E: Too many positional arguments for "__replace__" of "Coords"
Coords(2, 4).__replace__(23, 25) # E: Too many positional arguments for "__replace__" of "Coords"
Coords(2, 4).__replace__(x=23, y=25, z=42) # E: Unexpected keyword argument "z" for "__replace__" of "Coords"
from typing import Generic, TypeVar
T = TypeVar('T')
@dataclass
class Gen(Generic[T]):
x: T
replaced_2 = Gen(2).__replace__(x=2)
reveal_type(replaced_2) # N: Revealed type is "__main__.Gen[builtins.int]"
Gen(2).__replace__(x="not an int") # E: Argument "x" to "__replace__" of "Gen" has incompatible type "str"; expected "int"
[builtins fixtures/tuple.pyi]
[case testDunderReplaceAllowsCovariantDataclassField]
# flags: --python-version 3.13
from dataclasses import dataclass
from typing import Generic, TypeVar
T_co = TypeVar("T_co", covariant=True)
@dataclass(frozen=True)
class A(Generic[T_co]):
value: T_co
class B(Generic[T_co]):
def __replace__(self, *, value: T_co) -> B[T_co]:
return self
[builtins fixtures/tuple.pyi]
[case testDunderReplaceCovariantOverride]
# flags: --python-version 3.13 --enable-error-code mutable-override
from dataclasses import dataclass
from typing import Optional
from typing_extensions import dataclass_transform
@dataclass
class Base:
a: Optional[int]
@dataclass
class Child(Base):
a: int # E: Covariant override of a mutable attribute (base class "Base" defined the type as "int | None", expression has type "int")
@dataclass
class Other(Base):
a: str # E: Incompatible types in assignment (expression has type "str", base class "Base" defined the type as "int | None")
@dataclass_transform(kw_only_default=True)
class DCMeta(type): ...
class X(metaclass=DCMeta):
a: Optional[int]
class Y(X):
a: int # E: Covariant override of a mutable attribute (base class "X" defined the type as "int | None", expression has type "int")
[builtins fixtures/tuple.pyi]
[case testDunderReplaceDoesNotBlockPlainIssubclassNarrowing]
# https://github.com/python/mypy/issues/21635
# flags: --python-version 3.13
from dataclasses import dataclass
@dataclass
class A: ...
@dataclass
class M: ...
@dataclass
class B(A): ...
@dataclass
class C(M, A): ...
cls: type[A] = C
if issubclass(cls, M):
reveal_type(cls) # N: Revealed type is "type[__main__.<subclass of "__main__.A" and "__main__.M">]"
n: int = 'foo' # E: Incompatible types in assignment (expression has type "str", variable has type "int")
[builtins fixtures/isinstancelist.pyi]
[case testFrozenWithFinal]
from dataclasses import dataclass
from typing import Final
@dataclass(frozen=True)
class My:
a: Final = 1
b: Final[int] = 2
reveal_type(My.a) # N: Revealed type is "Literal[1]?"
reveal_type(My.b) # N: Revealed type is "builtins.int"
My.a = 1 # E: Cannot assign to final attribute "a"
My.b = 2 # E: Cannot assign to final attribute "b"
m = My()
reveal_type(m.a) # N: Revealed type is "Literal[1]?"
reveal_type(m.b) # N: Revealed type is "builtins.int"
m.a = 1 # E: Cannot assign to final attribute "a"
m.b = 2 # E: Cannot assign to final attribute "b"
[builtins fixtures/tuple.pyi]
[case testNoCrashForDataclassNamedTupleCombination]
# flags: --python-version 3.13
from dataclasses import dataclass
from typing import NamedTuple
@dataclass
class A(NamedTuple): # E: A NamedTuple cannot be a dataclass
i: int
class B1(NamedTuple):
i: int
@dataclass
class B2(B1): # E: A NamedTuple cannot be a dataclass
pass
[builtins fixtures/tuple.pyi]
[case testDataclassesTypeGuard]
import dataclasses
raw_target: object
if isinstance(raw_target, type) and dataclasses.is_dataclass(raw_target):
reveal_type(raw_target) # N: Revealed type is "type[dataclasses.DataclassInstance]"
[builtins fixtures/tuple.pyi]
[case testDataclassKwOnlyArgsLast]
from dataclasses import dataclass, field
@dataclass
class User:
id: int = field(kw_only=True)
name: str
User("Foo", id=0)
[builtins fixtures/tuple.pyi]
[case testDataclassKwOnlyArgsDefaultAllowedNonLast]
from dataclasses import dataclass, field
@dataclass
class User:
id: int = field(kw_only=True, default=0)
name: str
User() # E: Missing positional argument "name" in call to "User"
User("")
User(0) # E: Argument 1 to "User" has incompatible type "int"; expected "str"
User("", 0) # E: Too many positional arguments for "User"
User("", id=0)
User("", name="") # E: "User" gets multiple values for keyword argument "name"
[builtins fixtures/tuple.pyi]
[case testDataclassDefaultFactoryTypedDict]
from dataclasses import dataclass, field
from mypy_extensions import TypedDict
class Person(TypedDict, total=False):
name: str
@dataclass
class Job:
person: Person = field(default_factory=Person)
class PersonBad(TypedDict):
name: str
@dataclass
class JobBad:
person: PersonBad = field(default_factory=PersonBad) # E: Argument "default_factory" to "field" has incompatible type "type[PersonBad]"; expected "Callable[[], PersonBad]"
[builtins fixtures/dict.pyi]
[case testDataclassInitVarRedefinitionNoCrash]
# https://github.com/python/mypy/issues/19443
from dataclasses import InitVar, dataclass
class ClassA:
def value(self) -> int:
return 0
@dataclass
class ClassB(ClassA):
value: InitVar[int]
def value(self) -> int:
return 0
[builtins fixtures/dict.pyi]
[case testDataclassAllowsFinalField]
# flags: --python-version=3.13
from dataclasses import InitVar, dataclass
from typing import Final, ClassVar
@dataclass
class C:
x: int
y: Final[int]
z: ClassVar[Final[int]] = 4
c = C(1, 2)
c.y = 3 # E: Cannot assign to final attribute "y"
@dataclass
class D(C):
x: Final[int] # E: Cannot override writable attribute "x" with a final one
@dataclass
class Bad1:
x: Final[InitVar[int]] # E: InitVar cannot be final
@dataclass
class Bad2:
x: InitVar[Final[int]] # E: Final can be only used as an outermost qualifier in a variable annotation
[builtins fixtures/dict.pyi]
[case testNoCrashOnNestedSpecialFormsWithAnnotations]
import dataclasses
from typing import ClassVar, NamedTuple
from typing_extensions import TypedDict
@dataclasses.dataclass
class X:
a: int
TD: ClassVar = TypedDict("TD", {"a": int}) # E: Cannot declare the type of a TypedDict declaration
NT: ClassVar = NamedTuple("NT", [("a", int)]) # E: Cannot declare the type of a NamedTuple declaration
reveal_type(X) # N: Revealed type is "def (a: builtins.int) -> __main__.X"
reveal_type(X.TD) # N: Revealed type is "def (*, a: builtins.int) -> TypedDict('__main__.X.TD', {'a': builtins.int})"
reveal_type(X.NT) # N: Revealed type is "def (a: builtins.int) -> tuple[builtins.int, fallback=__main__.X.NT]"
tdx: X.TD
ntx: X.NT
reveal_type(tdx) # N: Revealed type is "TypedDict('__main__.X.TD', {'a': builtins.int})"
reveal_type(ntx) # N: Revealed type is "tuple[builtins.int, fallback=__main__.X.NT]"
@dataclasses.dataclass
class XOK:
a: int
TD = TypedDict("TD", {"a": int})
NT = NamedTuple("NT", [("a", int)])
reveal_type(XOK) # N: Revealed type is "def (a: builtins.int) -> __main__.XOK"
reveal_type(XOK.TD) # N: Revealed type is "def (*, a: builtins.int) -> TypedDict('__main__.XOK.TD', {'a': builtins.int})"
reveal_type(XOK.NT) # N: Revealed type is "def (a: builtins.int) -> tuple[builtins.int, fallback=__main__.XOK.NT]"
td: XOK.TD
nt: XOK.NT
reveal_type(td) # N: Revealed type is "TypedDict('__main__.XOK.TD', {'a': builtins.int})"
reveal_type(nt) # N: Revealed type is "tuple[builtins.int, fallback=__main__.XOK.NT]"
[builtins fixtures/dict.pyi]