Rooba
/
attrs
mirror of https://github.com/python-attrs/attrs.git
1
1
Fork 0
Code Issues Packages Projects Releases Wiki Activity
attrs/tests/test_mypy.yml

1475 lines
45 KiB
YAML
Raw Permalink Blame History

- case: attr_s_with_type_argument
parametrized:
- val: "a = attr.ib(type=int)"
- val: "a: int = attr.ib()"
main: |
import attr
@attr.s
class C:
{{ val }}
C() # E: Missing positional argument "a" in call to "C" [call-arg]
C(1)
C(a=1)
C(a="hi") # E: Argument "a" to "C" has incompatible type "str"; expected "int" [arg-type]
- case: attr_s_with_type_annotations
main: |
import attr
@attr.s
class C:
a: int = attr.ib()
C() # E: Missing positional argument "a" in call to "C" [call-arg]
C(1)
C(a=1)
C(a="hi") # E: Argument "a" to "C" has incompatible type "str"; expected "int" [arg-type]
- case: testAttrsSimple
main: |
import attr
@attr.s
class A:
a = attr.ib()
_b = attr.ib()
c = attr.ib(18)
_d = attr.ib(validator=None, default=18)
E = 18
def foo(self):
return self.a
reveal_type(A) # N: Revealed type is "def (a: Any, b: Any, c: Any =, d: Any =) -> main.A"
A(1, [2])
A(1, [2], '3', 4)
A(1, 2, 3, 4)
A(1, [2], '3', 4, 5) # E: Too many arguments for "A" [call-arg]
- case: testAttrsAnnotated
regex: true
main: |
import attr
from typing import List, ClassVar
@attr.s
class A:
a: int = attr.ib()
_b: List[int] = attr.ib()
c: str = attr.ib('18')
_d: int = attr.ib(validator=None, default=18)
E = 7
F: ClassVar[int] = 22
reveal_type(A) # N: Revealed type is "def \(a: builtins\.int, b: builtins\.list\[builtins\.int\], c: builtins\.str =, d: builtins\.int =\) -> main\.A"
A(1, [2])
A(1, [2], '3', 4)
A(1, 2, 3, 4) # E: Argument 2 to "A" has incompatible type "int"; expected "[Ll]ist\[int\]" \[arg-type\] # E: Argument 3 to "A" has incompatible type "int"; expected "str" \[arg-type\]
A(1, [2], '3', 4, 5) # E: Too many arguments for "A" \[call-arg\]
- case: testAttrsPython2Annotations
regex: true
main: |
import attr
from typing import List, ClassVar
@attr.s
class A:
a = attr.ib() # type: int
_b = attr.ib() # type: List[int]
c = attr.ib('18') # type: str
_d = attr.ib(validator=None, default=18) # type: int
E = 7
F: ClassVar[int] = 22
reveal_type(A) # N: Revealed type is "def \(a: builtins\.int, b: builtins\.list\[builtins\.int\], c: builtins\.str =, d: builtins\.int =\) -> main\.A"
A(1, [2])
A(1, [2], '3', 4)
A(1, 2, 3, 4) # E: Argument 2 to "A" has incompatible type "int"; expected "[Ll]ist\[int\]" \[arg-type\] # E: Argument 3 to "A" has incompatible type "int"; expected "str" \[arg-type\]
A(1, [2], '3', 4, 5) # E: Too many arguments for "A" \[call-arg\]
- case: testAttrsAutoAttribs
regex: true
main: |
import attr
from typing import List, ClassVar
@attr.s(auto_attribs=True)
class A:
a: int
_b: List[int]
c: str = '18'
_d: int = attr.ib(validator=None, default=18)
E = 7
F: ClassVar[int] = 22
reveal_type(A) # N: Revealed type is "def \(a: builtins\.int, b: builtins.list\[builtins.int\], c: builtins\.str =, d: builtins\.int =\) -> main\.A"
A(1, [2])
A(1, [2], '3', 4)
A(1, 2, 3, 4) # E: Argument 2 to "A" has incompatible type "int"; expected "[Ll]ist\[int\]" \[arg-type\] # E: Argument 3 to "A" has incompatible type "int"; expected "str" \[arg-type\]
A(1, [2], '3', 4, 5) # E: Too many arguments for "A" \[call-arg\]
- case: testAttrsUntypedNoUntypedDefs
mypy_config: |
disallow_untyped_defs = True
main: |
import attr
@attr.s
class A:
a = attr.ib() # E: Need type annotation for "a" [var-annotated]
_b = attr.ib() # E: Need type annotation for "_b" [var-annotated]
c = attr.ib(18) # E: Need type annotation for "c" [var-annotated]
_d = attr.ib(validator=None, default=18) # E: Need type annotation for "_d" [var-annotated]
E = 18
- case: testAttrsWrongReturnValue
main: |
import attr
@attr.s
class A:
x: int = attr.ib(8)
def foo(self) -> str:
return self.x # E: Incompatible return value type (got "int", expected "str") [return-value]
@attr.s
class B:
x = attr.ib(8) # type: int
def foo(self) -> str:
return self.x # E: Incompatible return value type (got "int", expected "str") [return-value]
@attr.dataclass
class C:
x: int = 8
def foo(self) -> str:
return self.x # E: Incompatible return value type (got "int", expected "str") [return-value]
@attr.s
class D:
x = attr.ib(8, type=int)
def foo(self) -> str:
return self.x # E: Incompatible return value type (got "int", expected "str") [return-value]
- case: testAttrsSeriousNames
regex: true
main: |
from attr import attrib, attrs
from typing import List
@attrs(init=True)
class A:
a = attrib()
_b: List[int] = attrib()
c = attrib(18)
_d = attrib(validator=None, default=18)
CLASS_VAR = 18
reveal_type(A) # N: Revealed type is "def \(a: Any, b: builtins.list\[builtins.int\], c: Any =, d: Any =\) -> main\.A"
A(1, [2])
A(1, [2], '3', 4)
A(1, 2, 3, 4) # E: Argument 2 to "A" has incompatible type "int"; expected "[Ll]ist\[int\]" \[arg-type\]
A(1, [2], '3', 4, 5) # E: Too many arguments for "A" \[call-arg\]
- case: testAttrsDefaultErrors
main: |
import attr
@attr.s
class A:
x = attr.ib(default=17)
y = attr.ib() # E: Non-default attributes not allowed after default attributes. [misc]
@attr.s(auto_attribs=True)
class B:
x: int = 17
y: int # E: Non-default attributes not allowed after default attributes. [misc]
@attr.s(auto_attribs=True)
class C:
x: int = attr.ib(default=17)
y: int # E: Non-default attributes not allowed after default attributes. [misc]
@attr.s
class D:
x = attr.ib()
y = attr.ib() # E: Non-default attributes not allowed after default attributes. [misc]
@x.default
def foo(self):
return 17
- case: testAttrsNotBooleans
main: |
import attr
x = True
@attr.s(cmp=x) # E: "cmp" argument must be a True, False, or None literal [literal-required]
class A:
a = attr.ib(init=x) # E: "init" argument must be a True or False literal [literal-required]
- case: testAttrsInitFalse
main: |
from attr import attrib, attrs
@attrs(auto_attribs=True, init=False)
class A:
a: int
_b: int
c: int = 18
_d: int = attrib(validator=None, default=18)
reveal_type(A) # N: Revealed type is "def () -> main.A"
A()
A(1, [2]) # E: Too many arguments for "A" [call-arg]
A(1, [2], '3', 4) # E: Too many arguments for "A" [call-arg]
- case: testAttrsInitAttribFalse
main: |
from attr import attrib, attrs
@attrs
class A:
a = attrib(init=False)
b = attrib()
reveal_type(A) # N: Revealed type is "def (b: Any) -> main.A"
- case: testAttrsCmpTrue
regex: true
main: |
from attr import attrib, attrs
@attrs(auto_attribs=True)
class A:
a: int
reveal_type(A) # N: Revealed type is "def \(a: builtins.int\) -> main.A"
reveal_type(A.__lt__) # N: Revealed type is "def \[_AT\] \(self: _AT`\d+, other: _AT`\d+\) -> builtins.bool"
reveal_type(A.__le__) # N: Revealed type is "def \[_AT\] \(self: _AT`\d+, other: _AT`\d+\) -> builtins.bool"
reveal_type(A.__gt__) # N: Revealed type is "def \[_AT\] \(self: _AT`\d+, other: _AT`\d+\) -> builtins.bool"
reveal_type(A.__ge__) # N: Revealed type is "def \[_AT\] \(self: _AT`\d+, other: _AT`\d+\) -> builtins.bool"
A(1) < A(2)
A(1) <= A(2)
A(1) > A(2)
A(1) >= A(2)
A(1) == A(2)
A(1) != A(2)
A(1) < 1 # E: Unsupported operand types for < \("A" and "int"\) \[operator\]
A(1) <= 1 # E: Unsupported operand types for <= \("A" and "int"\) \[operator\]
A(1) > 1 # E: Unsupported operand types for > \("A" and "int"\) \[operator\]
A(1) >= 1 # E: Unsupported operand types for >= \("A" and "int"\) \[operator\]
A(1) == 1
A(1) != 1
1 < A(1) # E: Unsupported operand types for < \("int" and "A"\) \[operator\]
1 <= A(1) # E: Unsupported operand types for <= \("int" and "A"\) \[operator\]
1 > A(1) # E: Unsupported operand types for > \("int" and "A"\) \[operator\]
1 >= A(1) # E: Unsupported operand types for >= \("int" and "A"\) \[operator\]
1 == A(1)
1 != A(1)
- case: testAttrsEqFalse
main: |
from attr import attrib, attrs
@attrs(auto_attribs=True, eq=False)
class A:
a: int
reveal_type(A) # N: Revealed type is "def (a: builtins.int) -> main.A"
reveal_type(A.__eq__) # N: Revealed type is "def (builtins.object, builtins.object) -> builtins.bool"
reveal_type(A.__ne__) # N: Revealed type is "def (builtins.object, builtins.object) -> builtins.bool"
A(1) < A(2) # E: Unsupported left operand type for < ("A") [operator]
A(1) <= A(2) # E: Unsupported left operand type for <= ("A") [operator]
A(1) > A(2) # E: Unsupported left operand type for > ("A") [operator]
A(1) >= A(2) # E: Unsupported left operand type for >= ("A") [operator]
A(1) == A(2)
A(1) != A(2)
A(1) < 1 # E: Unsupported operand types for > ("int" and "A") [operator]
A(1) <= 1 # E: Unsupported operand types for >= ("int" and "A") [operator]
A(1) > 1 # E: Unsupported operand types for < ("int" and "A") [operator]
A(1) >= 1 # E: Unsupported operand types for <= ("int" and "A") [operator]
A(1) == 1
A(1) != 1
1 < A(1) # E: Unsupported operand types for < ("int" and "A") [operator]
1 <= A(1) # E: Unsupported operand types for <= ("int" and "A") [operator]
1 > A(1) # E: Unsupported operand types for > ("int" and "A") [operator]
1 >= A(1) # E: Unsupported operand types for >= ("int" and "A") [operator]
1 == A(1)
1 != A(1)
- case: testAttrsOrderFalse
main: |
from attr import attrib, attrs
@attrs(auto_attribs=True, order=False)
class A:
a: int
reveal_type(A) # N: Revealed type is "def (a: builtins.int) -> main.A"
A(1) < A(2) # E: Unsupported left operand type for < ("A") [operator]
A(1) <= A(2) # E: Unsupported left operand type for <= ("A") [operator]
A(1) > A(2) # E: Unsupported left operand type for > ("A") [operator]
A(1) >= A(2) # E: Unsupported left operand type for >= ("A") [operator]
A(1) == A(2)
A(1) != A(2)
A(1) < 1 # E: Unsupported operand types for > ("int" and "A") [operator]
A(1) <= 1 # E: Unsupported operand types for >= ("int" and "A") [operator]
A(1) > 1 # E: Unsupported operand types for < ("int" and "A") [operator]
A(1) >= 1 # E: Unsupported operand types for <= ("int" and "A") [operator]
A(1) == 1
A(1) != 1
1 < A(1) # E: Unsupported operand types for < ("int" and "A") [operator]
1 <= A(1) # E: Unsupported operand types for <= ("int" and "A") [operator]
1 > A(1) # E: Unsupported operand types for > ("int" and "A") [operator]
1 >= A(1) # E: Unsupported operand types for >= ("int" and "A") [operator]
1 == A(1)
1 != A(1)
- case: testAttrsCmpEqOrderValues
main: |
from attr import attrib, attrs
@attrs(cmp=True)
class DeprecatedTrue:
...
@attrs(cmp=False)
class DeprecatedFalse:
...
@attrs(cmp=False, eq=True) # E: Don't mix "cmp" with "eq" and "order" [misc]
class Mixed:
...
@attrs(order=True, eq=False) # E: eq must be True if order is True [misc]
class Confused:
...
- case: testAttrsInheritance
main: |
import attr
@attr.s
class A:
a: int = attr.ib()
@attr.s
class B:
b: str = attr.ib()
@attr.s
class C(A, B):
c: bool = attr.ib()
reveal_type(C) # N: Revealed type is "def (a: builtins.int, b: builtins.str, c: builtins.bool) -> main.C"
- case: testAttrsNestedInClasses
main: |
import attr
@attr.s
class C:
y = attr.ib()
@attr.s
class D:
x: int = attr.ib()
reveal_type(C) # N: Revealed type is "def (y: Any) -> main.C"
reveal_type(C.D) # N: Revealed type is "def (x: builtins.int) -> main.C.D"
- case: testAttrsInheritanceOverride
main: |
import attr
@attr.s
class A:
a: int = attr.ib()
x: int = attr.ib()
@attr.s
class B(A):
b: str = attr.ib()
x: int = attr.ib(default=22)
@attr.s
class C(B):
c: bool = attr.ib() # No error here because the x below overwrites the x above.
x: int = attr.ib()
reveal_type(A) # N: Revealed type is "def (a: builtins.int, x: builtins.int) -> main.A"
reveal_type(B) # N: Revealed type is "def (a: builtins.int, b: builtins.str, x: builtins.int =) -> main.B"
reveal_type(C) # N: Revealed type is "def (a: builtins.int, b: builtins.str, c: builtins.bool, x: builtins.int) -> main.C"
- case: testAttrsTypeEquals
main: |
import attr
@attr.s
class A:
a = attr.ib(type=int)
b = attr.ib(18, type=int)
reveal_type(A) # N: Revealed type is "def (a: builtins.int, b: builtins.int =) -> main.A"
- case: testAttrsFrozen
main: |
import attr
@attr.s(frozen=True)
class A:
a = attr.ib()
a = A(5)
a.a = 16 # E: Property "a" defined in "A" is read-only [misc]
- case: testAttrsNextGenFrozen
main: |
from attr import frozen, field
@frozen
class A:
a = field()
a = A(5)
a.a = 16 # E: Property "a" defined in "A" is read-only [misc]
- case: testAttrsNextGenDetect
main: |
from attr import define, field
@define
class A:
a = field()
@define
class B:
a: int
@define
class C:
a: int = field()
b = field()
@define
class D:
a: int
b = field()
reveal_type(A) # N: Revealed type is "def (a: Any) -> main.A"
reveal_type(B) # N: Revealed type is "def (a: builtins.int) -> main.B"
reveal_type(C) # N: Revealed type is "def (a: builtins.int, b: Any) -> main.C"
reveal_type(D) # N: Revealed type is "def (b: Any) -> main.D"
- case: testAttrsDataClass
main: |
import attr
from typing import List, ClassVar
@attr.dataclass
class A:
a: int
_b: List[str]
c: str = '18'
_d: int = attr.ib(validator=None, default=18)
E = 7
F: ClassVar[int] = 22
reveal_type(A) # N: Revealed type is "def (a: builtins.int, b: builtins.list[builtins.str], c: builtins.str =, d: builtins.int =) -> main.A"
A(1, ['2'])
- case: testAttrsTypeAlias
main: |
from typing import List
import attr
Alias = List[int]
@attr.s(auto_attribs=True)
class A:
Alias2 = List[str]
x: Alias
y: Alias2 = attr.ib()
reveal_type(A) # N: Revealed type is "def (x: builtins.list[builtins.int], y: builtins.list[builtins.str]) -> main.A"
- case: testAttrsGeneric
regex: true
main: |
from typing import TypeVar, Generic, List
import attr
T = TypeVar('T')
@attr.s(auto_attribs=True)
class A(Generic[T]):
x: List[T]
y: T = attr.ib()
def foo(self) -> List[T]:
return [self.y]
def bar(self) -> T:
return self.x[0]
def problem(self) -> T:
return self.x # E: Incompatible return value type \(got "[Ll]ist\[T\]", expected "T"\) \[return-value\]
reveal_type(A) # N: Revealed type is "def \[T\] \(x: builtins\.list\[T`1\], y: T`1\) -> main.A\[T`1\]"
a = A([1], 2)
reveal_type(a) # N: Revealed type is "main\.A\[builtins.int\]"
reveal_type(a.x) # N: Revealed type is "builtins\.list\[builtins\.int\]"
reveal_type(a.y) # N: Revealed type is "builtins\.int"
A(['str'], 7) # E: Cannot infer type argument 1 of "A" \[misc\]
A([1], '2') # E: Cannot infer type argument 1 of "A" \[misc\]
- case: testAttrsUntypedGenericInheritance
main: |
from typing import Generic, TypeVar
import attr
T = TypeVar("T")
@attr.s(auto_attribs=True)
class Base(Generic[T]):
attr: T
@attr.s(auto_attribs=True)
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"
skip: True # Need to investigate why this is broken
- case: testAttrsGenericInheritance
main: |
from typing import Generic, TypeVar
import attr
S = TypeVar("S")
T = TypeVar("T")
@attr.s(auto_attribs=True)
class Base(Generic[T]):
attr: T
@attr.s(auto_attribs=True)
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"
- case: testAttrsGenericInheritance2
main: |
from typing import Generic, TypeVar
import attr
T1 = TypeVar("T1")
T2 = TypeVar("T2")
T3 = TypeVar("T3")
@attr.s(auto_attribs=True)
class Base(Generic[T1, T2, T3]):
one: T1
two: T2
three: T3
@attr.s(auto_attribs=True)
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*"
skip: True # Need to investigate why this is broken
- case: testAttrsMultiGenericInheritance
main: |
from typing import Generic, TypeVar
import attr
T = TypeVar("T")
@attr.s(auto_attribs=True, eq=False)
class Base(Generic[T]):
base_attr: T
S = TypeVar("S")
@attr.s(auto_attribs=True, eq=False)
class Middle(Base[int], Generic[S]):
middle_attr: S
@attr.s(auto_attribs=True, eq=False)
class Sub(Middle[str]):
pass
reveal_type(Sub.__init__)
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*"
skip: True # Need to investigate why this is broken
- case: testAttrsGenericClassmethod
main: |
from typing import TypeVar, Generic, Optional
import attr
T = TypeVar('T')
@attr.s(auto_attribs=True)
class A(Generic[T]):
x: Optional[T]
@classmethod
def clsmeth(cls) -> None:
reveal_type(cls) # N: Revealed type is "type[main.A[T`1]]"
- case: testAttrsForwardReference
main: |
from typing import Optional
import attr
@attr.s(auto_attribs=True)
class A:
parent: 'B'
@attr.s(auto_attribs=True)
class B:
parent: Optional[A]
reveal_type(A) # N: Revealed type is "def (parent: main.B) -> main.A"
reveal_type(B) # N: Revealed type is "def (parent: Union[main.A, None]) -> main.B"
A(B(None))
- case: testAttrsForwardReferenceInClass
main: |
from typing import Optional
import attr
@attr.s(auto_attribs=True)
class A:
parent: A.B
@attr.s(auto_attribs=True)
class B:
parent: Optional[A]
reveal_type(A) # N: Revealed type is "def (parent: main.A.B) -> main.A"
reveal_type(A.B) # N: Revealed type is "def (parent: Union[main.A, None]) -> main.A.B"
A(A.B(None))
- case: testAttrsImporting
main: |
from helper import A
reveal_type(A) # N: Revealed type is "def (a: builtins.int, b: builtins.str) -> helper.A"
files:
- path: helper.py
content: |
import attr
@attr.s(auto_attribs=True)
class A:
a: int
b: str = attr.ib()
- case: testAttrsOtherMethods
main: |
import attr
@attr.s(auto_attribs=True)
class A:
a: int
b: str = attr.ib()
@classmethod
def new(cls) -> A:
reveal_type(cls) # N: Revealed type is "type[main.A]"
return cls(6, 'hello')
@classmethod
def bad(cls) -> A:
return cls(17) # E: Missing positional argument "b" in call to "A" [call-arg]
def foo(self) -> int:
return self.a
reveal_type(A) # N: Revealed type is "def (a: builtins.int, b: builtins.str) -> main.A"
a = A.new()
reveal_type(a.foo) # N: Revealed type is "def () -> builtins.int"
- case: testAttrsOtherOverloads
main: |
import attr
from typing import overload, Union
@attr.s
class A:
a = attr.ib()
b = attr.ib(default=3)
@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"
- case: testAttrsDefaultDecorator
main: |
import attr
@attr.s
class C:
x: int = attr.ib(default=1)
y: int = attr.ib()
@y.default
def name_does_not_matter(self):
return self.x + 1
C()
- case: testAttrsValidatorDecorator
main: |
import attr
@attr.s
class C:
x = attr.ib()
@x.validator
def check(self, attribute, value):
if value > 42:
raise ValueError("x must be smaller or equal to 42")
C(42)
C(43)
- case: testAttrsLocalVariablesInClassMethod
main: |
import attr
@attr.s(auto_attribs=True)
class A:
a: int
b: int = attr.ib()
@classmethod
def new(cls, foo: int) -> A:
a = foo
b = a
return cls(a, b)
- case: testAttrsUnionForward
main: |
import attr
from typing import Union, List
@attr.s(auto_attribs=True)
class A:
frob: List['AOrB']
class B:
pass
AOrB = Union[A, B]
reveal_type(A) # N: Revealed type is "def (frob: builtins.list[Union[main.A, main.B]]) -> main.A"
reveal_type(B) # N: Revealed type is "def () -> main.B"
A([B()])
- case: testAttrsUsingConverter
main: |
import attr
import helper
def converter2(s:int) -> str:
return 'hello'
@attr.s
class C:
x: str = attr.ib(converter=helper.converter)
y: str = attr.ib(converter=converter2)
# Because of the converter the __init__ takes an int, but the variable is a str.
reveal_type(C) # N: Revealed type is "def (x: builtins.int, y: builtins.int) -> main.C"
reveal_type(C(15, 16).x) # N: Revealed type is "builtins.str"
files:
- path: helper.py
content: |
def converter(s:int) -> str:
return 'hello'
- case: testAttrsUsingBadConverter
skip: sys.version_info[:2] < (3, 10)
main: |
import attr
from typing import overload
@overload
def bad_overloaded_converter(x: int, y: int) -> int:
...
@overload
def bad_overloaded_converter(x: str, y: str) -> str:
...
def bad_overloaded_converter(x, y=7):
return x
def bad_converter() -> str:
return ''
@attr.dataclass
class A:
bad: str = attr.ib(converter=bad_converter)
bad_overloaded: int = attr.ib(converter=bad_overloaded_converter)
reveal_type(A)
out: |
main:15: error: Cannot determine __init__ type from converter [misc]
main:15: error: Argument "converter" has incompatible type "Callable[[], str]"; expected "Callable[[Any], Any] | Converter[Any, Never] | None" [arg-type]
main:16: error: Cannot determine __init__ type from converter [misc]
main:16: error: Argument "converter" has incompatible type overloaded function; expected "Callable[[Any], Any] | Converter[Any, Never] | None" [arg-type]
main:17: note: Revealed type is "def (bad: Any, bad_overloaded: Any) -> main.A"
- case: testAttrsUsingBadConverterReprocess
skip: sys.version_info[:2] < (3, 10)
main: |
import attr
from typing import overload
forward: 'A'
@overload
def bad_overloaded_converter(x: int, y: int) -> int:
...
@overload
def bad_overloaded_converter(x: str, y: str) -> str:
...
def bad_overloaded_converter(x, y=7):
return x
def bad_converter() -> str:
return ''
@attr.dataclass
class A:
bad: str = attr.ib(converter=bad_converter)
bad_overloaded: int = attr.ib(converter=bad_overloaded_converter)
reveal_type(A)
out: |
main:16: error: Cannot determine __init__ type from converter [misc]
main:16: error: Argument "converter" has incompatible type "Callable[[], str]"; expected "Callable[[Any], Any] | Converter[Any, Never] | None" [arg-type]
main:17: error: Cannot determine __init__ type from converter [misc]
main:17: error: Argument "converter" has incompatible type overloaded function; expected "Callable[[Any], Any] | Converter[Any, Never] | None" [arg-type]
main:18: note: Revealed type is "def (bad: Any, bad_overloaded: Any) -> main.A"
- case: testAttrsUsingUnsupportedConverter
main: |
import attr
class Thing:
def do_it(self, int) -> str:
return ""
thing = Thing()
def factory(default: int):
return 1
@attr.s
class C:
x: str = attr.ib(converter=thing.do_it) # E: Unsupported converter, only named functions, types and lambdas are currently supported [misc]
y: str = attr.ib(converter=lambda x: x)
z: str = attr.ib(converter=factory(8)) # E: Unsupported converter, only named functions, types and lambdas are currently supported [misc]
reveal_type(C) # N: Revealed type is "def (x: Any, y: Any, z: Any) -> main.C"
- case: testAttrsUsingConverterAndSubclass
main: |
import attr
def converter(s:int) -> str:
return 'hello'
@attr.s
class C:
x: str = attr.ib(converter=converter)
@attr.s
class A(C):
pass
# Because of the convert the __init__ takes an int, but the variable is a str.
reveal_type(A) # N: Revealed type is "def (x: builtins.int) -> main.A"
reveal_type(A(15).x) # N: Revealed type is "builtins.str"
- case: testAttrsUsingConverterWithTypes
main: |
from typing import overload
import attr
@attr.dataclass
class A:
x: str
@attr.s
class C:
x: complex = attr.ib(converter=complex)
y: int = attr.ib(converter=int)
z: A = attr.ib(converter=A)
o = C("1", "2", "3")
o = C(1, 2, "3")
- case: testThreeArgConverterTypes
main: |
from typing import Any
from attrs import AttrsInstance, Attribute, Converter
def my_converter(value: Any) -> str:
"""A converter that only takes the value."""
return str(value)
def my_converter_with_self(value: Any, self: AttrsInstance) -> str:
"""This converter takes the value and the self."""
return str(value)
def my_converter_with_field(value: Any, field: Attribute) -> str:
"""This converter takes the value and the field."""
return str(value)
reveal_type(Converter(my_converter))
Converter(my_converter_with_self)
Converter(my_converter_with_field)
reveal_type(Converter(my_converter_with_self, takes_self=True))
Converter(my_converter, takes_self=True)
Converter(my_converter_with_field, takes_self=True)
reveal_type(Converter(my_converter_with_field, takes_field=True))
Converter(my_converter, takes_field=True)
Converter(my_converter_with_self, takes_field=True)
out: |
main:17: note: Revealed type is "attr.Converter[Any, builtins.str]"
main:18: error: Argument 1 to "Converter" has incompatible type "Callable[[Any, AttrsInstance], str]"; expected "Callable[[Any], str]" [arg-type]
main:19: error: Argument 1 to "Converter" has incompatible type "Callable[[Any, Attribute[Any]], str]"; expected "Callable[[Any], str]" [arg-type]
main:21: note: Revealed type is "attr.Converter[Any, builtins.str]"
main:22: error: No overload variant of "Converter" matches argument types "Callable[[Any], str]", "bool" [call-overload]
main:22: note: Possible overload variants:
main:22: note: def [In, Out] Converter(self, converter: Callable[[In], Out]) -> Converter[In, Out]
main:22: note: def [In, Out] Converter(self, converter: Callable[[In, AttrsInstance, Attribute[Any]], Out], *, takes_self: Literal[True], takes_field: Literal[True]) -> Converter[In, Out]
main:22: note: def [In, Out] Converter(self, converter: Callable[[In, Attribute[Any]], Out], *, takes_field: Literal[True]) -> Converter[In, Out]
main:22: note: def [In, Out] Converter(self, converter: Callable[[In, AttrsInstance], Out], *, takes_self: Literal[True]) -> Converter[In, Out]
main:23: error: No overload variant of "Converter" matches argument types "Callable[[Any, Attribute[Any]], str]", "bool" [call-overload]
main:23: note: Possible overload variants:
main:23: note: def [In, Out] Converter(self, converter: Callable[[In], Out]) -> Converter[In, Out]
main:23: note: def [In, Out] Converter(self, converter: Callable[[In, AttrsInstance, Attribute[Any]], Out], *, takes_self: Literal[True], takes_field: Literal[True]) -> Converter[In, Out]
main:23: note: def [In, Out] Converter(self, converter: Callable[[In, Attribute[Any]], Out], *, takes_field: Literal[True]) -> Converter[In, Out]
main:23: note: def [In, Out] Converter(self, converter: Callable[[In, AttrsInstance], Out], *, takes_self: Literal[True]) -> Converter[In, Out]
main:25: note: Revealed type is "attr.Converter[Any, builtins.str]"
main:26: error: No overload variant of "Converter" matches argument types "Callable[[Any], str]", "bool" [call-overload]
main:26: note: Possible overload variants:
main:26: note: def [In, Out] Converter(self, converter: Callable[[In], Out]) -> Converter[In, Out]
main:26: note: def [In, Out] Converter(self, converter: Callable[[In, AttrsInstance, Attribute[Any]], Out], *, takes_self: Literal[True], takes_field: Literal[True]) -> Converter[In, Out]
main:26: note: def [In, Out] Converter(self, converter: Callable[[In, Attribute[Any]], Out], *, takes_field: Literal[True]) -> Converter[In, Out]
main:26: note: def [In, Out] Converter(self, converter: Callable[[In, AttrsInstance], Out], *, takes_self: Literal[True]) -> Converter[In, Out]
main:27: error: No overload variant of "Converter" matches argument types "Callable[[Any, AttrsInstance], str]", "bool" [call-overload]
main:27: note: Possible overload variants:
main:27: note: def [In, Out] Converter(self, converter: Callable[[In], Out]) -> Converter[In, Out]
main:27: note: def [In, Out] Converter(self, converter: Callable[[In, AttrsInstance, Attribute[Any]], Out], *, takes_self: Literal[True], takes_field: Literal[True]) -> Converter[In, Out]
main:27: note: def [In, Out] Converter(self, converter: Callable[[In, Attribute[Any]], Out], *, takes_field: Literal[True]) -> Converter[In, Out]
main:27: note: def [In, Out] Converter(self, converter: Callable[[In, AttrsInstance], Out], *, takes_self: Literal[True]) -> Converter[In, Out]
- case: testAttrsCmpWithSubclasses
regex: true
main: |
import attr
@attr.s
class A: pass
@attr.s
class B: pass
@attr.s
class C(A, B): pass
@attr.s
class D(A): pass
reveal_type(A.__lt__) # N: Revealed type is "def \[_AT\] \(self: _AT`\d+, other: _AT`\d+\) -> builtins.bool"
reveal_type(B.__lt__) # N: Revealed type is "def \[_AT\] \(self: _AT`\d+, other: _AT`\d+\) -> builtins.bool"
reveal_type(C.__lt__) # N: Revealed type is "def \[_AT\] \(self: _AT`\d+, other: _AT`\d+\) -> builtins.bool"
reveal_type(D.__lt__) # N: Revealed type is "def \[_AT\] \(self: _AT`\d+, other: _AT`\d+\) -> builtins.bool"
A() < A()
B() < B()
A() < B() # E: Unsupported operand types for < \("A" and "B"\) \[operator\]
C() > A()
C() > B()
C() > C()
C() > D() # E: Unsupported operand types for > \("C" and "D"\) \[operator\]
D() >= A()
D() >= B() # E: Unsupported operand types for >= \("D" and "B"\) \[operator\]
D() >= C() # E: Unsupported operand types for >= \("D" and "C"\) \[operator\]
D() >= D()
A() <= 1 # E: Unsupported operand types for <= \("A" and "int"\) \[operator\]
B() <= 1 # E: Unsupported operand types for <= \("B" and "int"\) \[operator\]
C() <= 1 # E: Unsupported operand types for <= \("C" and "int"\) \[operator\]
D() <= 1 # E: Unsupported operand types for <= \("D" and "int"\) \[operator\]
- case: testAttrsComplexSuperclass
main: |
import attr
@attr.s
class C:
x: int = attr.ib(default=1)
y: int = attr.ib()
@y.default
def name_does_not_matter(self):
return self.x + 1
@attr.s
class A(C):
z: int = attr.ib(default=18)
reveal_type(C) # N: Revealed type is "def (x: builtins.int =, y: builtins.int =) -> main.C"
reveal_type(A) # N: Revealed type is "def (x: builtins.int =, y: builtins.int =, z: builtins.int =) -> main.A"
- case: testAttrsMultiAssign
main: |
import attr
@attr.s
class A:
x, y, z = attr.ib(), attr.ib(type=int), attr.ib(default=17)
reveal_type(A) # N: Revealed type is "def (x: Any, y: builtins.int, z: Any =) -> main.A"
- case: testAttrsMultiAssign2
main: |
import attr
@attr.s
class A:
x = y = z = attr.ib() # E: Too many names for one attribute [misc]
- case: testAttrsPrivateInit
main: |
import attr
@attr.s
class C:
_x = attr.ib(init=False, default=42)
C()
C(_x=42) # E: Unexpected keyword argument "_x" for "C" [call-arg]
- case: testAttrsAutoMustBeAll
main: |
import attr
@attr.s(auto_attribs=True)
class A:
a: int
b = 17
# The following forms are not allowed with auto_attribs=True
c = attr.ib() # E: Need type annotation for "c" [var-annotated]
d, e = attr.ib(), attr.ib() # E: Need type annotation for "d" [var-annotated] # E: Need type annotation for "e" [var-annotated]
f = g = attr.ib() # E: Need type annotation for "f" [var-annotated] # E: Need type annotation for "g" [var-annotated]
- case: testAttrsRepeatedName
main: |
import attr
@attr.s
class A:
a = attr.ib(default=8)
b = attr.ib()
a = attr.ib()
reveal_type(A) # N: Revealed type is "def (b: Any, a: Any) -> main.A"
@attr.s
class B:
a: int = attr.ib(default=8)
b: int = attr.ib()
a: int = attr.ib() # E: Name "a" already defined on line 10 [no-redef]
reveal_type(B) # N: Revealed type is "def (b: builtins.int, a: builtins.int) -> main.B"
@attr.s(auto_attribs=True)
class C:
a: int = 8
b: int
a: int = attr.ib() # E: Name "a" already defined on line 16 [no-redef]
reveal_type(C) # N: Revealed type is "def (a: builtins.int, b: builtins.int) -> main.C"
- case: testAttrsFrozenSubclass
main: |
import attr
@attr.dataclass
class NonFrozenBase:
a: int
@attr.dataclass(frozen=True)
class FrozenBase:
a: int
@attr.dataclass(frozen=True)
class FrozenNonFrozen(NonFrozenBase):
b: int
@attr.dataclass(frozen=True)
class FrozenFrozen(FrozenBase):
b: int
@attr.dataclass
class NonFrozenFrozen(FrozenBase):
b: int
# Make sure these are untouched
non_frozen_base = NonFrozenBase(1)
non_frozen_base.a = 17
frozen_base = FrozenBase(1)
frozen_base.a = 17 # E: Property "a" defined in "FrozenBase" is read-only [misc]
a = FrozenNonFrozen(1, 2)
a.a = 17 # E: Property "a" defined in "FrozenNonFrozen" is read-only [misc]
a.b = 17 # E: Property "b" defined in "FrozenNonFrozen" is read-only [misc]
b = FrozenFrozen(1, 2)
b.a = 17 # E: Property "a" defined in "FrozenFrozen" is read-only [misc]
b.b = 17 # E: Property "b" defined in "FrozenFrozen" is read-only [misc]
c = NonFrozenFrozen(1, 2)
c.a = 17 # E: Property "a" defined in "NonFrozenFrozen" is read-only [misc]
c.b = 17 # E: Property "b" defined in "NonFrozenFrozen" is read-only [misc]
- case: testAttrsCallableAttributes
main: |
from typing import Callable
import attr
def blah(a: int, b: int) -> bool:
return True
@attr.s(auto_attribs=True)
class F:
_cb: Callable[[int, int], bool] = blah
def foo(self) -> bool:
return self._cb(5, 6)
@attr.s
class G:
_cb: Callable[[int, int], bool] = attr.ib(blah)
def foo(self) -> bool:
return self._cb(5, 6)
@attr.s(auto_attribs=True, frozen=True)
class FFrozen(F):
def bar(self) -> bool:
return self._cb(5, 6)
- case: testAttrsWithFactory
main: |
from typing import List
import attr
def my_factory() -> int:
return 7
@attr.s
class A:
x: List[int] = attr.ib(factory=list)
y: int = attr.ib(factory=my_factory)
A()
- case: testAttrsFactoryAndDefault
main: |
import attr
@attr.s
class A:
x: int = attr.ib(factory=int, default=7) # E: Can't pass both "default" and "factory". [misc]
- case: testAttrsFactoryBadReturn
regex: true
main: |
import attr
def my_factory() -> int:
return 7
@attr.s
class A:
x: int = attr.ib(factory=list) # E: Incompatible types in assignment \(expression has type "[Ll]ist\[.*\]", variable has type "int"\) \[assignment\]
y: str = attr.ib(factory=my_factory) # E: Incompatible types in assignment \(expression has type "int", variable has type "str"\) \[assignment\]
- case: testAttrsDefaultAndInit
main: |
import attr
@attr.s
class C:
a = attr.ib(init=False, default=42)
b = attr.ib() # Ok because previous attribute is init=False
c = attr.ib(default=44)
d = attr.ib(init=False) # Ok because this attribute is init=False
e = attr.ib() # E: Non-default attributes not allowed after default attributes. [misc]
- case: testAttrsOptionalConverter
main: |
# flags: --strict-optional
import attr
from attr.converters import optional
from typing import Optional
def converter(s:int) -> str:
return 'hello'
@attr.s
class A:
y: Optional[int] = attr.ib(converter=optional(int))
z: Optional[str] = attr.ib(converter=optional(converter))
A(None, None)
- case: testAttrsTypeVarNoCollision
main: |
from typing import TypeVar, Generic
import attr
T = TypeVar("T", bytes, str)
# Make sure the generated __le__ (and friends) don't use T for their arguments.
@attr.s(auto_attribs=True)
class A(Generic[T]):
v: T
- case: testAttrsKwOnlyAttrib
main: |
import attr
@attr.s
class A:
a = attr.ib(kw_only=True)
A() # E: Missing named argument "a" for "A" [call-arg]
A(15) # E: Too many positional arguments for "A" [misc]
A(a=15)
- case: testAttrsKwOnlyClass
main: |
import attr
@attr.s(kw_only=True, auto_attribs=True)
class A:
a: int
b: bool
A() # E: Missing named argument "a" for "A" [call-arg] # E: Missing named argument "b" for "A" [call-arg]
A(b=True, a=15)
- case: testAttrsKwOnlyClassNoInit
main: |
import attr
@attr.s(kw_only=True)
class B:
a = attr.ib(init=False)
b = attr.ib()
B(b=True)
- case: testAttrsKwOnlyWithDefault
main: |
import attr
@attr.s
class C:
a = attr.ib(0)
b = attr.ib(kw_only=True)
c = attr.ib(16, kw_only=True)
C(b=17)
- case: testAttrsKwOnlyClassWithMixedDefaults
main: |
import attr
@attr.s(kw_only=True)
class D:
a = attr.ib(10)
b = attr.ib()
c = attr.ib(15)
D(b=17)
- case: testAttrsKwOnlySubclass
main: |
import attr
@attr.s
class A2:
a = attr.ib(default=0)
@attr.s
class B2(A2):
b = attr.ib(kw_only=True)
B2(b=1)
- case: testAttrsNonKwOnlyAfterKwOnly
main: |
import attr
@attr.s(kw_only=True)
class A:
a = attr.ib(default=0)
@attr.s
class B(A):
b = attr.ib()
@attr.s
class C:
a = attr.ib(kw_only=True)
b = attr.ib(15)
- case: testAttrsDisallowUntypedWorksForward
main: |
# flags: --disallow-untyped-defs
import attr
from typing import List
@attr.s
class B:
x: C = attr.ib()
class C(List[C]):
pass
reveal_type(B) # N: Revealed type is "def (x: main.C) -> main.B"
- case: testDisallowUntypedWorksForwardBad
mypy_config: disallow_untyped_defs = True
main: |
import attr
@attr.s
class B:
x = attr.ib() # E: Need type annotation for "x" [var-annotated]
reveal_type(B) # N: Revealed type is "def (x: Any) -> main.B"
- case: testAttrsDefaultDecoratorDeferred
main: |
defer: Yes
import attr
@attr.s
class C:
x: int = attr.ib(default=1)
y: int = attr.ib()
@y.default
def inc(self):
return self.x + 1
class Yes: ...
- case: testAttrsValidatorDecoratorDeferred
main: |
defer: Yes
import attr
@attr.s
class C:
x = attr.ib()
@x.validator
def check(self, attribute, value):
if value > 42:
raise ValueError("x must be smaller or equal to 42")
C(42)
C(43)
class Yes: ...
- case: testTypeInAttrUndefined
main: |
import attr
@attr.s
class C:
total = attr.ib(type=Bad) # E: Name "Bad" is not defined [name-defined]
- case: testTypeInAttrForwardInRuntime
main: |
import attr
@attr.s
class C:
total = attr.ib(type=Forward)
reveal_type(C.total) # N: Revealed type is "main.Forward"
C('no') # E: Argument 1 to "C" has incompatible type "str"; expected "Forward" [arg-type]
class Forward: ...
- case: testDefaultInAttrForward
main: |
import attr
@attr.s
class C:
total = attr.ib(default=func())
def func() -> int: return 5
C()
C(1)
C(1, 2) # E: Too many arguments for "C" [call-arg]
- case: testTypeInAttrUndefinedFrozen
main: |
import attr
@attr.s(frozen=True)
class C:
total = attr.ib(type=Bad) # E: Name "Bad" is not defined [name-defined]
C(0).total = 1 # E: Property "total" defined in "C" is read-only [misc]
- case: testTypeInAttrDeferredStar
main: |
import lib
files:
- path: lib.py
content: |
import attr
MYPY = False
if MYPY: # Force deferral
from other import *
@attr.s
class C:
total = attr.ib(type=int)
C() # E: Missing positional argument "total" in call to "C" [call-arg]
C('no') # E: Argument 1 to "C" has incompatible type "str"; expected "int" [arg-type]
- path: other.py
content: |
import lib
- case: testAttrsDefaultsMroOtherFile
main: |
import a
files:
- path: a.py
content: |
import attr
from b import A1, A2
@attr.s
class Asdf(A1, A2): # E: Non-default attributes not allowed after default attributes. [misc]
pass
- path: b.py
content: |
import attr
@attr.s
class A1:
a: str = attr.ib('test')
@attr.s
class A2:
b: int = attr.ib()
- case: testAttrsInheritanceNoAnnotation
main: |
import attr
@attr.s
class A:
foo = attr.ib() # type: int
x = 0
@attr.s
class B(A):
foo = x
reveal_type(B) # N: Revealed type is "def (foo: builtins.int) -> main.B"
- case: testFields
regex: true
main: |
from attrs import define, fields
@define
class A:
a: int
b: str
reveal_type(fields(A)) # N: Revealed type is "[Tt]uple\[attr.Attribute\[builtins.int\], attr.Attribute\[builtins.str\], fallback=main.A.__main_A_AttrsAttributes__\]"
- case: testFieldsError
regex: true
main: |
from attrs import fields
class A:
a: int
b: str
fields(A) # E: Argument 1 to "fields" has incompatible type "[Tt]ype\[A\]"; expected "[Tt]ype\[AttrsInstance\]" \[arg-type\]
- case: testAsDict
main: |
from attrs import asdict, define
@define
class A:
a: int
asdict(A(1))
- case: testAsDictError
main: |
from attrs import asdict
class A:
a: int
asdict(A()) # E: Argument 1 to "asdict" has incompatible type "A"; expected "AttrsInstance" [arg-type]
- case: testHasTypeGuard
main: |
from attrs import define, has
@define
class A:
pass
reveal_type(A) # N: Revealed type is "def () -> main.A"
if has(A):
reveal_type(A) # N: Revealed type is "type[attr.AttrsInstance]"
Reference in New Issue View Git Blame Copy Permalink