Path 1: 535 calls (0.55)

→ name 'self' (483) 'cls' (49) 'truc' (1) 'bar_' (1) 'tastes_bitter' (1)

→ node FunctionDef (526) AsyncFunctionDef (9)

→ stmt AssignName (535)

→ argnames ['self'] (308) ['cls'] (28) ['self', 'param'] (22) ['self', 'index'] (9) ['self', 'format_spec'] (7) ['self', 'key'] (5) ['self', 'predicate'] (5) ['s...

→ nonlocal_names set() (534) {'some_attr'} (1)

↩ return None (535)

8 run 19 not run

1def _check_unused_arguments(
2        self,
3        name: str,
4        node: nodes.FunctionDef,
5        stmt: nodes.NodeNG,
6        argnames: list[str],
7        nonlocal_names: Iterable[str],
8    ) -> None:
9        is_method = node.is_method()
10        klass = node.parent.frame(future=True)
11        if is_method and isinstance(klass, nodes.ClassDef):
12            confidence = (
13                INFERENCE if utils.has_known_bases(klass) else INFERENCE_FAILURE
14            )
15        else:
16            confidence = HIGH
17
18        if is_method:
19            # Don't warn for the first argument of a (non static) method
20            if node.type != "staticmethod" and name == argnames[0]:
21                return
22            # Don't warn for argument of an overridden method
23            overridden = overridden_method(klass, node.name)
24            if overridden is not None and name in overridden.argnames():
25                return
26            if node.name in utils.PYMETHODS and node.name not in (
27                "__init__",
28                "__new__",
29            ):
30                return
31        # Don't check callback arguments
32        if any(
33            node.name.startswith(cb) or node.name.endswith(cb)
34            for cb in self.linter.config.callbacks
35        ):
36            return
37        # Don't check arguments of singledispatch.register function.
38        if utils.is_registered_in_singledispatch_function(node):
39            return
40
41        # Don't check function stubs created only for type information
42        if utils.is_overload_stub(node):
43            return
44
45        # Don't check protocol classes
46        if utils.is_protocol_class(klass):
47            return
48
49        if name in nonlocal_names:
50            return
51
52        self.add_message("unused-argument", args=name, node=stmt, confidence=confidence)
            

Path 2: 305 calls (0.31)

→ name 'self' (114) 'arg1' (18) 'arg2' (14) 'kwargs' (14) 'args' (11) 'x' (11) 'y' (11) 'doc_type' (10) 'name' (9) 'arg' (8)

→ node FunctionDef (304) AsyncFunctionDef (1)

→ stmt AssignName (279) Arguments (26)

→ argnames ['self'] (104) ['self', 'doc_type'] (20) ['x', 'y', 'z'] (18) ['arg1', 'args', 'arg2', 'kwargs'] (16) ['arg1', 'arg2', 'arg3', 'arg4'] (16) ['args', '...

→ nonlocal_names set() (305)

12 run 15 not run

1def _check_unused_arguments(
2        self,
3        name: str,
4        node: nodes.FunctionDef,
5        stmt: nodes.NodeNG,
6        argnames: list[str],
7        nonlocal_names: Iterable[str],
8    ) -> None:
9        is_method = node.is_method()
10        klass = node.parent.frame(future=True)
11        if is_method and isinstance(klass, nodes.ClassDef):
12            confidence = (
13                INFERENCE if utils.has_known_bases(klass) else INFERENCE_FAILURE
14            )
15        else:
16            confidence = HIGH
17
18        if is_method:
19            # Don't warn for the first argument of a (non static) method
20            if node.type != "staticmethod" and name == argnames[0]:
21                return
22            # Don't warn for argument of an overridden method
23            overridden = overridden_method(klass, node.name)
24            if overridden is not None and name in overridden.argnames():
25                return
26            if node.name in utils.PYMETHODS and node.name not in (
27                "__init__",
28                "__new__",
29            ):
30                return
31        # Don't check callback arguments
32        if any(
33            node.name.startswith(cb) or node.name.endswith(cb)
34            for cb in self.linter.config.callbacks
35        ):
36            return
37        # Don't check arguments of singledispatch.register function.
38        if utils.is_registered_in_singledispatch_function(node):
39            return
40
41        # Don't check function stubs created only for type information
42        if utils.is_overload_stub(node):
43            return
44
45        # Don't check protocol classes
46        if utils.is_protocol_class(klass):
47            return
48
49        if name in nonlocal_names:
50            return
51
52        self.add_message("unused-argument", args=name, node=stmt, confidence=confidence)
            

Path 3: 58 calls (0.06)

→ name 'value' (5) 'arg' (4) 'kwargs' (3) 'source' (3) 'obj' (3) 'a' (3) 'error' (2) 'item' (2) 'option' (2) 'second' (2)

→ node FunctionDef (58)

→ stmt AssignName (54) Arguments (4)

→ argnames ['self', 'a', 'b', 'c'] (6) ['self', 'value'] (5) ['self', 'arg'] (3) ['cls', 'source'] (3) ['self', 'obj'] (3) ['self', 'x', 'y', 'z'] (3) ['self', '...

→ nonlocal_names set() (58)

17 run 10 not run

1def _check_unused_arguments(
2        self,
3        name: str,
4        node: nodes.FunctionDef,
5        stmt: nodes.NodeNG,
6        argnames: list[str],
7        nonlocal_names: Iterable[str],
8    ) -> None:
9        is_method = node.is_method()
10        klass = node.parent.frame(future=True)
11        if is_method and isinstance(klass, nodes.ClassDef):
12            confidence = (
13                INFERENCE if utils.has_known_bases(klass) else INFERENCE_FAILURE
14            )
15        else:
16            confidence = HIGH
17
18        if is_method:
19            # Don't warn for the first argument of a (non static) method
20            if node.type != "staticmethod" and name == argnames[0]:
21                return
22            # Don't warn for argument of an overridden method
23            overridden = overridden_method(klass, node.name)
24            if overridden is not None and name in overridden.argnames():
25                return
26            if node.name in utils.PYMETHODS and node.name not in (
27                "__init__",
28                "__new__",
29            ):
30                return
31        # Don't check callback arguments
32        if any(
33            node.name.startswith(cb) or node.name.endswith(cb)
34            for cb in self.linter.config.callbacks
35        ):
36            return
37        # Don't check arguments of singledispatch.register function.
38        if utils.is_registered_in_singledispatch_function(node):
39            return
40
41        # Don't check function stubs created only for type information
42        if utils.is_overload_stub(node):
43            return
44
45        # Don't check protocol classes
46        if utils.is_protocol_class(klass):
47            return
48
49        if name in nonlocal_names:
50            return
51
52        self.add_message("unused-argument", args=name, node=stmt, confidence=confidence)
            

Path 4: 40 calls (0.04)

→ name 'format_spec' (8) 'index' (6) 'other' (4) 'argv' (3) 'cls' (2) 'instance' (2) 'owner' (2) 'exc_type' (2) 'exc_value' (2) 'traceback' (2)

→ node FunctionDef (40)

→ stmt AssignName (40)

→ argnames ['self', 'format_spec'] (7) ['self', 'exc_type', 'exc_value', 'traceback'] (6) ['self', 'index'] (6) ['self', 'instance', 'owner'] (4) ['self', 'inst'...

→ nonlocal_names set() (40)

↩ return None (40)

11 run 16 not run

1def _check_unused_arguments(
2        self,
3        name: str,
4        node: nodes.FunctionDef,
5        stmt: nodes.NodeNG,
6        argnames: list[str],
7        nonlocal_names: Iterable[str],
8    ) -> None:
9        is_method = node.is_method()
10        klass = node.parent.frame(future=True)
11        if is_method and isinstance(klass, nodes.ClassDef):
12            confidence = (
13                INFERENCE if utils.has_known_bases(klass) else INFERENCE_FAILURE
14            )
15        else:
16            confidence = HIGH
17
18        if is_method:
19            # Don't warn for the first argument of a (non static) method
20            if node.type != "staticmethod" and name == argnames[0]:
21                return
22            # Don't warn for argument of an overridden method
23            overridden = overridden_method(klass, node.name)
24            if overridden is not None and name in overridden.argnames():
25                return
26            if node.name in utils.PYMETHODS and node.name not in (
27                "__init__",
28                "__new__",
29            ):
30                return
31        # Don't check callback arguments
32        if any(
33            node.name.startswith(cb) or node.name.endswith(cb)
34            for cb in self.linter.config.callbacks
35        ):
36            return
37        # Don't check arguments of singledispatch.register function.
38        if utils.is_registered_in_singledispatch_function(node):
39            return
40
41        # Don't check function stubs created only for type information
42        if utils.is_overload_stub(node):
43            return
44
45        # Don't check protocol classes
46        if utils.is_protocol_class(klass):
47            return
48
49        if name in nonlocal_names:
50            return
51
52        self.add_message("unused-argument", args=name, node=stmt, confidence=confidence)
            

Path 5: 16 calls (0.02)

→ name 'num' (2) 'arg1' (1) 'name' (1) 'start' (1) 'count' (1) 'last_values' (1) 'arg' (1) 'kwargs' (1) 'param' (1) 'fillchar' (1)

→ node FunctionDef (16)

→ stmt AssignName (15) Arguments (1)

→ argnames ['name', 'start', 'count', 'last_values'] (4) ['self', 'num'] (2) ['self', 'aaa', 'aab', 'aac'] (2) ['self', 'arg2', 'arg1'] (1) ['self', 'arg', 'valu...

→ nonlocal_names set() (16)

↩ return None (16)

10 run 17 not run

1def _check_unused_arguments(
2        self,
3        name: str,
4        node: nodes.FunctionDef,
5        stmt: nodes.NodeNG,
6        argnames: list[str],
7        nonlocal_names: Iterable[str],
8    ) -> None:
9        is_method = node.is_method()
10        klass = node.parent.frame(future=True)
11        if is_method and isinstance(klass, nodes.ClassDef):
12            confidence = (
13                INFERENCE if utils.has_known_bases(klass) else INFERENCE_FAILURE
14            )
15        else:
16            confidence = HIGH
17
18        if is_method:
19            # Don't warn for the first argument of a (non static) method
20            if node.type != "staticmethod" and name == argnames[0]:
21                return
22            # Don't warn for argument of an overridden method
23            overridden = overridden_method(klass, node.name)
24            if overridden is not None and name in overridden.argnames():
25                return
26            if node.name in utils.PYMETHODS and node.name not in (
27                "__init__",
28                "__new__",
29            ):
30                return
31        # Don't check callback arguments
32        if any(
33            node.name.startswith(cb) or node.name.endswith(cb)
34            for cb in self.linter.config.callbacks
35        ):
36            return
37        # Don't check arguments of singledispatch.register function.
38        if utils.is_registered_in_singledispatch_function(node):
39            return
40
41        # Don't check function stubs created only for type information
42        if utils.is_overload_stub(node):
43            return
44
45        # Don't check protocol classes
46        if utils.is_protocol_class(klass):
47            return
48
49        if name in nonlocal_names:
50            return
51
52        self.add_message("unused-argument", args=name, node=stmt, confidence=confidence)
            

Path 6: 10 calls (0.01)

→ name 'arg' (6) 'arg1' (2) 'data' (2)

→ node FunctionDef (10)

→ stmt AssignName (10)

→ argnames ['arg'] (6) ['arg1'] (2) ['data'] (2)

→ nonlocal_names set() (10)

↩ return None (10)

10 run 17 not run

1def _check_unused_arguments(
2        self,
3        name: str,
4        node: nodes.FunctionDef,
5        stmt: nodes.NodeNG,
6        argnames: list[str],
7        nonlocal_names: Iterable[str],
8    ) -> None:
9        is_method = node.is_method()
10        klass = node.parent.frame(future=True)
11        if is_method and isinstance(klass, nodes.ClassDef):
12            confidence = (
13                INFERENCE if utils.has_known_bases(klass) else INFERENCE_FAILURE
14            )
15        else:
16            confidence = HIGH
17
18        if is_method:
19            # Don't warn for the first argument of a (non static) method
20            if node.type != "staticmethod" and name == argnames[0]:
21                return
22            # Don't warn for argument of an overridden method
23            overridden = overridden_method(klass, node.name)
24            if overridden is not None and name in overridden.argnames():
25                return
26            if node.name in utils.PYMETHODS and node.name not in (
27                "__init__",
28                "__new__",
29            ):
30                return
31        # Don't check callback arguments
32        if any(
33            node.name.startswith(cb) or node.name.endswith(cb)
34            for cb in self.linter.config.callbacks
35        ):
36            return
37        # Don't check arguments of singledispatch.register function.
38        if utils.is_registered_in_singledispatch_function(node):
39            return
40
41        # Don't check function stubs created only for type information
42        if utils.is_overload_stub(node):
43            return
44
45        # Don't check protocol classes
46        if utils.is_protocol_class(klass):
47            return
48
49        if name in nonlocal_names:
50            return
51
52        self.add_message("unused-argument", args=name, node=stmt, confidence=confidence)
            

Path 7: 6 calls (0.01)

→ name 'var' (2) 'option' (2) 'param' (2)

→ node FunctionDef (6)

→ stmt AssignName (6)

→ argnames ['self', 'var'] (2) ['self', 'option'] (2) ['self', 'param'] (2)

→ nonlocal_names set() (6)

↩ return None (6)

15 run 12 not run

1def _check_unused_arguments(
2        self,
3        name: str,
4        node: nodes.FunctionDef,
5        stmt: nodes.NodeNG,
6        argnames: list[str],
7        nonlocal_names: Iterable[str],
8    ) -> None:
9        is_method = node.is_method()
10        klass = node.parent.frame(future=True)
11        if is_method and isinstance(klass, nodes.ClassDef):
12            confidence = (
13                INFERENCE if utils.has_known_bases(klass) else INFERENCE_FAILURE
14            )
15        else:
16            confidence = HIGH
17
18        if is_method:
19            # Don't warn for the first argument of a (non static) method
20            if node.type != "staticmethod" and name == argnames[0]:
21                return
22            # Don't warn for argument of an overridden method
23            overridden = overridden_method(klass, node.name)
24            if overridden is not None and name in overridden.argnames():
25                return
26            if node.name in utils.PYMETHODS and node.name not in (
27                "__init__",
28                "__new__",
29            ):
30                return
31        # Don't check callback arguments
32        if any(
33            node.name.startswith(cb) or node.name.endswith(cb)
34            for cb in self.linter.config.callbacks
35        ):
36            return
37        # Don't check arguments of singledispatch.register function.
38        if utils.is_registered_in_singledispatch_function(node):
39            return
40
41        # Don't check function stubs created only for type information
42        if utils.is_overload_stub(node):
43            return
44
45        # Don't check protocol classes
46        if utils.is_protocol_class(klass):
47            return
48
49        if name in nonlocal_names:
50            return
51
52        self.add_message("unused-argument", args=name, node=stmt, confidence=confidence)
            

Path 8: 4 calls (0.0)

→ name 'arg' (3) 'verbose' (1)

→ node FunctionDef (4)

→ stmt AssignName (4)

→ argnames ['arg'] (3) ['arg', 'verbose'] (1)

→ nonlocal_names set() (4)

↩ return None (4)

9 run 18 not run

1def _check_unused_arguments(
2        self,
3        name: str,
4        node: nodes.FunctionDef,
5        stmt: nodes.NodeNG,
6        argnames: list[str],
7        nonlocal_names: Iterable[str],
8    ) -> None:
9        is_method = node.is_method()
10        klass = node.parent.frame(future=True)
11        if is_method and isinstance(klass, nodes.ClassDef):
12            confidence = (
13                INFERENCE if utils.has_known_bases(klass) else INFERENCE_FAILURE
14            )
15        else:
16            confidence = HIGH
17
18        if is_method:
19            # Don't warn for the first argument of a (non static) method
20            if node.type != "staticmethod" and name == argnames[0]:
21                return
22            # Don't warn for argument of an overridden method
23            overridden = overridden_method(klass, node.name)
24            if overridden is not None and name in overridden.argnames():
25                return
26            if node.name in utils.PYMETHODS and node.name not in (
27                "__init__",
28                "__new__",
29            ):
30                return
31        # Don't check callback arguments
32        if any(
33            node.name.startswith(cb) or node.name.endswith(cb)
34            for cb in self.linter.config.callbacks
35        ):
36            return
37        # Don't check arguments of singledispatch.register function.
38        if utils.is_registered_in_singledispatch_function(node):
39            return
40
41        # Don't check function stubs created only for type information
42        if utils.is_overload_stub(node):
43            return
44
45        # Don't check protocol classes
46        if utils.is_protocol_class(klass):
47            return
48
49        if name in nonlocal_names:
50            return
51
52        self.add_message("unused-argument", args=name, node=stmt, confidence=confidence)
            

Path 9: 3 calls (0.0)

→ name 'blob' (3)

→ node FunctionDef (3)

→ stmt AssignName (3)

→ argnames ['self', 'blob'] (3)

→ nonlocal_names set() (3)

↩ return None (3)

16 run 11 not run

1def _check_unused_arguments(
2        self,
3        name: str,
4        node: nodes.FunctionDef,
5        stmt: nodes.NodeNG,
6        argnames: list[str],
7        nonlocal_names: Iterable[str],
8    ) -> None:
9        is_method = node.is_method()
10        klass = node.parent.frame(future=True)
11        if is_method and isinstance(klass, nodes.ClassDef):
12            confidence = (
13                INFERENCE if utils.has_known_bases(klass) else INFERENCE_FAILURE
14            )
15        else:
16            confidence = HIGH
17
18        if is_method:
19            # Don't warn for the first argument of a (non static) method
20            if node.type != "staticmethod" and name == argnames[0]:
21                return
22            # Don't warn for argument of an overridden method
23            overridden = overridden_method(klass, node.name)
24            if overridden is not None and name in overridden.argnames():
25                return
26            if node.name in utils.PYMETHODS and node.name not in (
27                "__init__",
28                "__new__",
29            ):
30                return
31        # Don't check callback arguments
32        if any(
33            node.name.startswith(cb) or node.name.endswith(cb)
34            for cb in self.linter.config.callbacks
35        ):
36            return
37        # Don't check arguments of singledispatch.register function.
38        if utils.is_registered_in_singledispatch_function(node):
39            return
40
41        # Don't check function stubs created only for type information
42        if utils.is_overload_stub(node):
43            return
44
45        # Don't check protocol classes
46        if utils.is_protocol_class(klass):
47            return
48
49        if name in nonlocal_names:
50            return
51
52        self.add_message("unused-argument", args=name, node=stmt, confidence=confidence)
            

Path 10: 3 calls (0.0)

→ name 'abc' (2) 'defg' (1)

→ node FunctionDef (3)

→ stmt AssignName (3)

→ argnames ['abc', 'defg'] (2) ['abc'] (1)

→ nonlocal_names set() (3)

↩ return None (3)

⚠ exception GeneratorExit (3)

8 run 19 not run

1def _check_unused_arguments(
2        self,
3        name: str,
4        node: nodes.FunctionDef,
5        stmt: nodes.NodeNG,
6        argnames: list[str],
7        nonlocal_names: Iterable[str],
8    ) -> None:
9        is_method = node.is_method()
10        klass = node.parent.frame(future=True)
11        if is_method and isinstance(klass, nodes.ClassDef):
12            confidence = (
13                INFERENCE if utils.has_known_bases(klass) else INFERENCE_FAILURE
14            )
15        else:
16            confidence = HIGH
17
18        if is_method:
19            # Don't warn for the first argument of a (non static) method
20            if node.type != "staticmethod" and name == argnames[0]:
21                return
22            # Don't warn for argument of an overridden method
23            overridden = overridden_method(klass, node.name)
24            if overridden is not None and name in overridden.argnames():
25                return
26            if node.name in utils.PYMETHODS and node.name not in (
27                "__init__",
28                "__new__",
29            ):
30                return
31        # Don't check callback arguments
32        if any(
33            node.name.startswith(cb) or node.name.endswith(cb)
34            for cb in self.linter.config.callbacks
35        ):
36            return
37        # Don't check arguments of singledispatch.register function.
38        if utils.is_registered_in_singledispatch_function(node):
39            return
40
41        # Don't check function stubs created only for type information
42        if utils.is_overload_stub(node):
43            return
44
45        # Don't check protocol classes
46        if utils.is_protocol_class(klass):
47            return
48
49        if name in nonlocal_names:
50            return
51
52        self.add_message("unused-argument", args=name, node=stmt, confidence=confidence)
            

Path 11: 1 calls (0.0)

→ name 'initial' (1)

→ node FunctionDef (1)

→ stmt AssignName (1)

→ argnames ['initial'] (1)

→ nonlocal_names {'initial'} (1)

↩ return None (1)

12 run 15 not run

1def _check_unused_arguments(
2        self,
3        name: str,
4        node: nodes.FunctionDef,
5        stmt: nodes.NodeNG,
6        argnames: list[str],
7        nonlocal_names: Iterable[str],
8    ) -> None:
9        is_method = node.is_method()
10        klass = node.parent.frame(future=True)
11        if is_method and isinstance(klass, nodes.ClassDef):
12            confidence = (
13                INFERENCE if utils.has_known_bases(klass) else INFERENCE_FAILURE
14            )
15        else:
16            confidence = HIGH
17
18        if is_method:
19            # Don't warn for the first argument of a (non static) method
20            if node.type != "staticmethod" and name == argnames[0]:
21                return
22            # Don't warn for argument of an overridden method
23            overridden = overridden_method(klass, node.name)
24            if overridden is not None and name in overridden.argnames():
25                return
26            if node.name in utils.PYMETHODS and node.name not in (
27                "__init__",
28                "__new__",
29            ):
30                return
31        # Don't check callback arguments
32        if any(
33            node.name.startswith(cb) or node.name.endswith(cb)
34            for cb in self.linter.config.callbacks
35        ):
36            return
37        # Don't check arguments of singledispatch.register function.
38        if utils.is_registered_in_singledispatch_function(node):
39            return
40
41        # Don't check function stubs created only for type information
42        if utils.is_overload_stub(node):
43            return
44
45        # Don't check protocol classes
46        if utils.is_protocol_class(klass):
47            return
48
49        if name in nonlocal_names:
50            return
51
52        self.add_message("unused-argument", args=name, node=stmt, confidence=confidence)