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
124
125
126
127
128
129
130
|
# pylint: disable=missing-docstring,too-few-public-methods
def test_unused(first, second, _not_used): # [unused-argument, unused-argument]
pass
def test_prefixed_with_ignored(first, ignored_second):
first()
def test_prefixed_with_unused(first, unused_second):
first()
# for Sub.inherited, only the warning for "aay" is desired.
# The warnings for "aab" and "aac" are most likely false positives though,
# because there could be another subclass that overrides the same method and does
# use the arguments (e.g. Sub2)
class Base:
"parent"
def inherited(self, aaa, aab, aac):
"abstract method"
raise NotImplementedError
class Sub(Base):
"child 1"
def inherited(self, aaa, aab, aac):
"overridden method, though don't use every argument"
return aaa
def newmethod(self, aax, aay): # [unused-argument]
"another method, warning for aay desired"
return self, aax
class Sub2(Base):
"child 1"
def inherited(self, aaa, aab, aac):
"overridden method, use every argument"
return aaa + aab + aac
def metadata_from_dict(key):
"""
Should not raise unused-argument message because key is
used inside comprehension dict
"""
return {key: str(value) for key, value in key.items()}
def metadata_from_dict_2(key):
"""Similar, but with more nesting"""
return {key: (a, b) for key, (a, b) in key.items()}
# pylint: disable=too-few-public-methods, wrong-import-position
def function(arg=1): # [unused-argument]
"""ignore arg"""
class AAAA:
"""dummy class"""
def method(self, arg): # [unused-argument]
"""dummy method"""
print(self)
def __init__(self, *unused_args, **unused_kwargs):
pass
@classmethod
def selected(cls, *args, **kwargs): # [unused-argument, unused-argument]
"""called by the registry when the vobject has been selected.
"""
return cls
def using_inner_function(self, etype, size=1):
"""return a fake result set for a particular entity type"""
rset = AAAA([('A',)]*size, f'{etype} X',
description=[(etype,)]*size)
def inner(row, col=0, etype=etype, req=self, rset=rset):
"""inner using all its argument"""
# pylint: disable=maybe-no-member
return req.vreg.etype_class(etype)(req, rset, row, col)
# pylint: disable = attribute-defined-outside-init
rset.get_entity = inner
class BBBB:
"""dummy class"""
def __init__(self, arg): # [unused-argument]
"""Constructor with an extra parameter. Should raise a warning"""
self.spam = 1
# Regression test for https://github.com/PyCQA/pylint/issues/5771
# involving keyword-only arguments
class Ancestor:
def __init__(self):
self.thing = None
def set_thing(self, thing, *, other=None): # [unused-argument]
self.thing = thing
class Descendant(Ancestor):
def set_thing(self, thing, *, other=None):
"""Subclass does not raise unused-argument"""
self.thing = thing
# Test that Class with both `__init__` and `__new__` don't check
# on `__new__` for unused arguments
# pylint: disable=invalid-name
class TestClassWithInitAndNew:
def __init__(self, argA, argB):
self.argA = argA
self.argB = argB
def __new__(cls, argA, argB):
return object.__new__(cls)
# Test that `__new__` method is checked for unused arguments
# when `__init__` is not in the Class
class TestClassWithOnlyNew:
def __new__(cls, argA, argB): # [unused-argument, unused-argument]
return object.__new__(cls)
|
