1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
|
# pylint: disable=missing-docstring,pointless-statement,expression-not-assigned,too-few-public-methods,import-error,no-init
# standard types
1 in [1, 2, 3]
1 in {'a': 1, 'b': 2}
1 in {1, 2, 3}
1 in (1, 2, 3)
'1' in "123"
'1' in u"123"
'1' in bytearray(b"123")
1 in frozenset([1, 2, 3])
# comprehensions
1 in [x ** 2 % 10 for x in range(10)]
1 in {x ** 2 % 10 for x in range(10)}
1 in {x: x ** 2 % 10 for x in range(10)}
# iterators
1 in iter([1, 2, 3])
# generator
def count(upto=float("inf")):
i = 0
while True:
if i > upto:
break
yield i
i += 1
10 in count(upto=10)
# custom instance
class UniversalContainer(object):
def __contains__(self, key):
return True
42 in UniversalContainer()
# custom iterable
class CustomIterable(object):
def __iter__(self):
return iter((1, 2, 3))
3 in CustomIterable()
# old-style iterable
class OldStyleIterable(object):
def __getitem__(self, key):
if key < 10:
return 2 ** key
else:
raise IndexError("bad index")
64 in OldStyleIterable()
# do not emit warning if class has unknown bases
from some_missing_module import ImportedClass
class MaybeIterable(ImportedClass):
pass
10 in MaybeIterable()
# do not emit warning inside mixins/abstract/base classes
class UsefulMixin(object):
stuff = None
def get_stuff(self):
return self.stuff
def act(self, thing):
stuff = self.get_stuff()
if thing in stuff:
pass
class BaseThing(object):
valid_values = None
def validate(self, value):
if self.valid_values is None:
return True
else:
# error should not be emitted here
return value in self.valid_values
class AbstractThing(object):
valid_values = None
def validate(self, value):
if self.valid_values is None:
return True
else:
# error should not be emitted here
return value in self.valid_values
# class is not named as abstract
# but still is deduceably abstract
class Thing(object):
valid_values = None
def __init__(self):
self._init_values()
def validate(self, value):
if self.valid_values is None:
return True
else:
# error should not be emitted here
return value in self.valid_values
def _init_values(self):
raise NotImplementedError
# error cases
42 in 42 # [unsupported-membership-test]
42 not in None # [unsupported-membership-test]
42 in 8.5 # [unsupported-membership-test]
class EmptyClass(object):
pass
42 not in EmptyClass() # [unsupported-membership-test]
42 in EmptyClass # [unsupported-membership-test]
42 not in count # [unsupported-membership-test]
42 in range # [unsupported-membership-test]
|
