Path 1: 981 calls (0.67)

→ name 'self' (598) 'cls' (52) 'arg' (23) 'arg1' (22) 'kwargs' (18) 'arg2' (15) 'args' (12) 'x' (12) 'y' (12) 'name' (10)

→ node FunctionDef (971) AsyncFunctionDef (10)

→ stmt AssignName (950) Arguments (31)

→ global_names set() (981)

→ nonlocal_names set() (979) {'some_attr'} (1) {'initial'} (1)

→ comprehension_target_names set() (980) {'mauris'} (1)

10 run 44 not run

1def _check_is_unused(
2        self,
3        name: str,
4        node: nodes.FunctionDef,
5        stmt: nodes.NodeNG,
6        global_names: set[str],
7        nonlocal_names: Iterable[str],
8        comprehension_target_names: Iterable[str],
9    ) -> None:
10        # Ignore some special names specified by user configuration.
11        if self._is_name_ignored(stmt, name):
12            return
13        # Ignore names that were added dynamically to the Function scope
14        if (
15            isinstance(node, nodes.FunctionDef)
16            and name == "__class__"
17            and len(node.locals["__class__"]) == 1
18            and isinstance(node.locals["__class__"][0], nodes.ClassDef)
19        ):
20            return
21
22        # Ignore names imported by the global statement.
23        if isinstance(stmt, (nodes.Global, nodes.Import, nodes.ImportFrom)):
24            # Detect imports, assigned to global statements.
25            if global_names and _import_name_is_global(stmt, global_names):
26                return
27
28        # Ignore names in comprehension targets
29        if name in comprehension_target_names:
30            return
31
32        # Ignore names in string literal type annotation.
33        if name in self._type_annotation_names:
34            return
35
36        argnames = node.argnames()
37        # Care about functions with unknown argument (builtins)
38        if name in argnames:
39            self._check_unused_arguments(name, node, stmt, argnames, nonlocal_names)
40        else:
41            if stmt.parent and isinstance(
42                stmt.parent, (nodes.Assign, nodes.AnnAssign, nodes.Tuple, nodes.For)
43            ):
44                if name in nonlocal_names:
45                    return
46
47            qname = asname = None
48            if isinstance(stmt, (nodes.Import, nodes.ImportFrom)):
49                # Need the complete name, which we don't have in .locals.
50                if len(stmt.names) > 1:
51                    import_names = next(
52                        (names for names in stmt.names if name in names), None
53                    )
54                else:
55                    import_names = stmt.names[0]
56                if import_names:
57                    qname, asname = import_names
58                    name = asname or qname
59
60            if _has_locals_call_after_node(stmt, node.scope()):
61                message_name = "possibly-unused-variable"
62            else:
63                if isinstance(stmt, nodes.Import):
64                    if asname is not None:
65                        msg = f"{qname} imported as {asname}"
66                    else:
67                        msg = f"import {name}"
68                    self.add_message("unused-import", args=msg, node=stmt)
69                    return
70                if isinstance(stmt, nodes.ImportFrom):
71                    if asname is not None:
72                        msg = f"{qname} imported from {stmt.modname} as {asname}"
73                    else:
74                        msg = f"{name} imported from {stmt.modname}"
75                    self.add_message("unused-import", args=msg, node=stmt)
76                    return
77                message_name = "unused-variable"
78
79            if isinstance(stmt, nodes.FunctionDef) and stmt.decorators:
80                return
81
82            # Don't check function stubs created only for type information
83            if utils.is_overload_stub(node):
84                return
85
86            # Special case for exception variable
87            if isinstance(stmt.parent, nodes.ExceptHandler) and any(
88                n.name == name for n in stmt.parent.nodes_of_class(nodes.Name)
89            ):
90                return
91
92            self.add_message(message_name, args=name, node=stmt)
            

Path 2: 255 calls (0.18)

→ name 'a' (36) 'c' (24) 'b' (23) 'i' (16) 'var' (12) 'variable' (10) 'd' (9) 'value' (5) 'e' (4) 'f' (4)

→ node FunctionDef (251) AsyncFunctionDef (4)

→ stmt AssignName (255)

→ global_names set() (255)

→ nonlocal_names set() (254) {'count'} (1)

→ comprehension_target_names set() (235) {'i'} (17) {'m'} (2) {'mauris'} (1)

22 run 32 not run

1def _check_is_unused(
2        self,
3        name: str,
4        node: nodes.FunctionDef,
5        stmt: nodes.NodeNG,
6        global_names: set[str],
7        nonlocal_names: Iterable[str],
8        comprehension_target_names: Iterable[str],
9    ) -> None:
10        # Ignore some special names specified by user configuration.
11        if self._is_name_ignored(stmt, name):
12            return
13        # Ignore names that were added dynamically to the Function scope
14        if (
15            isinstance(node, nodes.FunctionDef)
16            and name == "__class__"
17            and len(node.locals["__class__"]) == 1
18            and isinstance(node.locals["__class__"][0], nodes.ClassDef)
19        ):
20            return
21
22        # Ignore names imported by the global statement.
23        if isinstance(stmt, (nodes.Global, nodes.Import, nodes.ImportFrom)):
24            # Detect imports, assigned to global statements.
25            if global_names and _import_name_is_global(stmt, global_names):
26                return
27
28        # Ignore names in comprehension targets
29        if name in comprehension_target_names:
30            return
31
32        # Ignore names in string literal type annotation.
33        if name in self._type_annotation_names:
34            return
35
36        argnames = node.argnames()
37        # Care about functions with unknown argument (builtins)
38        if name in argnames:
39            self._check_unused_arguments(name, node, stmt, argnames, nonlocal_names)
40        else:
41            if stmt.parent and isinstance(
42                stmt.parent, (nodes.Assign, nodes.AnnAssign, nodes.Tuple, nodes.For)
43            ):
44                if name in nonlocal_names:
45                    return
46
47            qname = asname = None
48            if isinstance(stmt, (nodes.Import, nodes.ImportFrom)):
49                # Need the complete name, which we don't have in .locals.
50                if len(stmt.names) > 1:
51                    import_names = next(
52                        (names for names in stmt.names if name in names), None
53                    )
54                else:
55                    import_names = stmt.names[0]
56                if import_names:
57                    qname, asname = import_names
58                    name = asname or qname
59
60            if _has_locals_call_after_node(stmt, node.scope()):
61                message_name = "possibly-unused-variable"
62            else:
63                if isinstance(stmt, nodes.Import):
64                    if asname is not None:
65                        msg = f"{qname} imported as {asname}"
66                    else:
67                        msg = f"import {name}"
68                    self.add_message("unused-import", args=msg, node=stmt)
69                    return
70                if isinstance(stmt, nodes.ImportFrom):
71                    if asname is not None:
72                        msg = f"{qname} imported from {stmt.modname} as {asname}"
73                    else:
74                        msg = f"{name} imported from {stmt.modname}"
75                    self.add_message("unused-import", args=msg, node=stmt)
76                    return
77                message_name = "unused-variable"
78
79            if isinstance(stmt, nodes.FunctionDef) and stmt.decorators:
80                return
81
82            # Don't check function stubs created only for type information
83            if utils.is_overload_stub(node):
84                return
85
86            # Special case for exception variable
87            if isinstance(stmt.parent, nodes.ExceptHandler) and any(
88                n.name == name for n in stmt.parent.nodes_of_class(nodes.Name)
89            ):
90                return
91
92            self.add_message(message_name, args=name, node=stmt)
            

Path 3: 130 calls (0.09)

→ name '_' (89) '_inner' (5) '_new' (3) '_args' (2) '_kwargs' (2) '_x' (2) '_internal_func' (2) 'ignored_barg' (1) '_abc' (1) '_value' (1)

→ node FunctionDef (128) AsyncFunctionDef (2)

→ stmt AssignName (113) FunctionDef (10) Arguments (7)

→ global_names set() (130)

→ nonlocal_names set() (130)

→ comprehension_target_names set() (126) {'my_int'} (3) {'key'} (1)

↩ return None (130)

2 run 52 not run

1def _check_is_unused(
2        self,
3        name: str,
4        node: nodes.FunctionDef,
5        stmt: nodes.NodeNG,
6        global_names: set[str],
7        nonlocal_names: Iterable[str],
8        comprehension_target_names: Iterable[str],
9    ) -> None:
10        # Ignore some special names specified by user configuration.
11        if self._is_name_ignored(stmt, name):
12            return
13        # Ignore names that were added dynamically to the Function scope
14        if (
15            isinstance(node, nodes.FunctionDef)
16            and name == "__class__"
17            and len(node.locals["__class__"]) == 1
18            and isinstance(node.locals["__class__"][0], nodes.ClassDef)
19        ):
20            return
21
22        # Ignore names imported by the global statement.
23        if isinstance(stmt, (nodes.Global, nodes.Import, nodes.ImportFrom)):
24            # Detect imports, assigned to global statements.
25            if global_names and _import_name_is_global(stmt, global_names):
26                return
27
28        # Ignore names in comprehension targets
29        if name in comprehension_target_names:
30            return
31
32        # Ignore names in string literal type annotation.
33        if name in self._type_annotation_names:
34            return
35
36        argnames = node.argnames()
37        # Care about functions with unknown argument (builtins)
38        if name in argnames:
39            self._check_unused_arguments(name, node, stmt, argnames, nonlocal_names)
40        else:
41            if stmt.parent and isinstance(
42                stmt.parent, (nodes.Assign, nodes.AnnAssign, nodes.Tuple, nodes.For)
43            ):
44                if name in nonlocal_names:
45                    return
46
47            qname = asname = None
48            if isinstance(stmt, (nodes.Import, nodes.ImportFrom)):
49                # Need the complete name, which we don't have in .locals.
50                if len(stmt.names) > 1:
51                    import_names = next(
52                        (names for names in stmt.names if name in names), None
53                    )
54                else:
55                    import_names = stmt.names[0]
56                if import_names:
57                    qname, asname = import_names
58                    name = asname or qname
59
60            if _has_locals_call_after_node(stmt, node.scope()):
61                message_name = "possibly-unused-variable"
62            else:
63                if isinstance(stmt, nodes.Import):
64                    if asname is not None:
65                        msg = f"{qname} imported as {asname}"
66                    else:
67                        msg = f"import {name}"
68                    self.add_message("unused-import", args=msg, node=stmt)
69                    return
70                if isinstance(stmt, nodes.ImportFrom):
71                    if asname is not None:
72                        msg = f"{qname} imported from {stmt.modname} as {asname}"
73                    else:
74                        msg = f"{name} imported from {stmt.modname}"
75                    self.add_message("unused-import", args=msg, node=stmt)
76                    return
77                message_name = "unused-variable"
78
79            if isinstance(stmt, nodes.FunctionDef) and stmt.decorators:
80                return
81
82            # Don't check function stubs created only for type information
83            if utils.is_overload_stub(node):
84                return
85
86            # Special case for exception variable
87            if isinstance(stmt.parent, nodes.ExceptHandler) and any(
88                n.name == name for n in stmt.parent.nodes_of_class(nodes.Name)
89            ):
90                return
91
92            self.add_message(message_name, args=name, node=stmt)
            

Path 4: 20 calls (0.01)

→ name 'inner_func' (3) 'stuff' (2) 'MyContextManager' (1) 'fh' (1) 'fp' (1) 'fp2' (1) 'func' (1) 'best' (1) 'inner' (1) 'other_stuff' (1)

→ node FunctionDef (19) AsyncFunctionDef (1)

→ stmt FunctionDef (12) AssignName (5) ClassDef (2) AsyncFunctionDef (1)

→ global_names set() (20)

→ nonlocal_names set() (12) {'c', 'a'} (4) {'b', 'c'} (2) {'a'} (1) {'nonlocal_'} (1)

→ comprehension_target_names set() (20)

21 run 33 not run

1def _check_is_unused(
2        self,
3        name: str,
4        node: nodes.FunctionDef,
5        stmt: nodes.NodeNG,
6        global_names: set[str],
7        nonlocal_names: Iterable[str],
8        comprehension_target_names: Iterable[str],
9    ) -> None:
10        # Ignore some special names specified by user configuration.
11        if self._is_name_ignored(stmt, name):
12            return
13        # Ignore names that were added dynamically to the Function scope
14        if (
15            isinstance(node, nodes.FunctionDef)
16            and name == "__class__"
17            and len(node.locals["__class__"]) == 1
18            and isinstance(node.locals["__class__"][0], nodes.ClassDef)
19        ):
20            return
21
22        # Ignore names imported by the global statement.
23        if isinstance(stmt, (nodes.Global, nodes.Import, nodes.ImportFrom)):
24            # Detect imports, assigned to global statements.
25            if global_names and _import_name_is_global(stmt, global_names):
26                return
27
28        # Ignore names in comprehension targets
29        if name in comprehension_target_names:
30            return
31
32        # Ignore names in string literal type annotation.
33        if name in self._type_annotation_names:
34            return
35
36        argnames = node.argnames()
37        # Care about functions with unknown argument (builtins)
38        if name in argnames:
39            self._check_unused_arguments(name, node, stmt, argnames, nonlocal_names)
40        else:
41            if stmt.parent and isinstance(
42                stmt.parent, (nodes.Assign, nodes.AnnAssign, nodes.Tuple, nodes.For)
43            ):
44                if name in nonlocal_names:
45                    return
46
47            qname = asname = None
48            if isinstance(stmt, (nodes.Import, nodes.ImportFrom)):
49                # Need the complete name, which we don't have in .locals.
50                if len(stmt.names) > 1:
51                    import_names = next(
52                        (names for names in stmt.names if name in names), None
53                    )
54                else:
55                    import_names = stmt.names[0]
56                if import_names:
57                    qname, asname = import_names
58                    name = asname or qname
59
60            if _has_locals_call_after_node(stmt, node.scope()):
61                message_name = "possibly-unused-variable"
62            else:
63                if isinstance(stmt, nodes.Import):
64                    if asname is not None:
65                        msg = f"{qname} imported as {asname}"
66                    else:
67                        msg = f"import {name}"
68                    self.add_message("unused-import", args=msg, node=stmt)
69                    return
70                if isinstance(stmt, nodes.ImportFrom):
71                    if asname is not None:
72                        msg = f"{qname} imported from {stmt.modname} as {asname}"
73                    else:
74                        msg = f"{name} imported from {stmt.modname}"
75                    self.add_message("unused-import", args=msg, node=stmt)
76                    return
77                message_name = "unused-variable"
78
79            if isinstance(stmt, nodes.FunctionDef) and stmt.decorators:
80                return
81
82            # Don't check function stubs created only for type information
83            if utils.is_overload_stub(node):
84                return
85
86            # Special case for exception variable
87            if isinstance(stmt.parent, nodes.ExceptHandler) and any(
88                n.name == name for n in stmt.parent.nodes_of_class(nodes.Name)
89            ):
90                return
91
92            self.add_message(message_name, args=name, node=stmt)
            

Path 5: 17 calls (0.01)

→ name 'a' (3) 'c' (2) 'count' (2) 'some_num' (2) 'myint' (1) 'self' (1) 'i' (1) 'ann' (1) 'assign' (1) 'unrelated' (1)

→ node FunctionDef (17)

→ stmt AssignName (17)

→ global_names set() (17)

→ nonlocal_names {'a'} (2) {'c', 'a'} (2) {'ann', 'assign'} (2) {'count'} (2) {'some_num'} (2) {'c'} (1) {'myint'} (1) {'self'} (1) {'i'} (1) {'unrelated'} (1)

→ comprehension_target_names set() (17)

↩ return None (17)

13 run 41 not run

1def _check_is_unused(
2        self,
3        name: str,
4        node: nodes.FunctionDef,
5        stmt: nodes.NodeNG,
6        global_names: set[str],
7        nonlocal_names: Iterable[str],
8        comprehension_target_names: Iterable[str],
9    ) -> None:
10        # Ignore some special names specified by user configuration.
11        if self._is_name_ignored(stmt, name):
12            return
13        # Ignore names that were added dynamically to the Function scope
14        if (
15            isinstance(node, nodes.FunctionDef)
16            and name == "__class__"
17            and len(node.locals["__class__"]) == 1
18            and isinstance(node.locals["__class__"][0], nodes.ClassDef)
19        ):
20            return
21
22        # Ignore names imported by the global statement.
23        if isinstance(stmt, (nodes.Global, nodes.Import, nodes.ImportFrom)):
24            # Detect imports, assigned to global statements.
25            if global_names and _import_name_is_global(stmt, global_names):
26                return
27
28        # Ignore names in comprehension targets
29        if name in comprehension_target_names:
30            return
31
32        # Ignore names in string literal type annotation.
33        if name in self._type_annotation_names:
34            return
35
36        argnames = node.argnames()
37        # Care about functions with unknown argument (builtins)
38        if name in argnames:
39            self._check_unused_arguments(name, node, stmt, argnames, nonlocal_names)
40        else:
41            if stmt.parent and isinstance(
42                stmt.parent, (nodes.Assign, nodes.AnnAssign, nodes.Tuple, nodes.For)
43            ):
44                if name in nonlocal_names:
45                    return
46
47            qname = asname = None
48            if isinstance(stmt, (nodes.Import, nodes.ImportFrom)):
49                # Need the complete name, which we don't have in .locals.
50                if len(stmt.names) > 1:
51                    import_names = next(
52                        (names for names in stmt.names if name in names), None
53                    )
54                else:
55                    import_names = stmt.names[0]
56                if import_names:
57                    qname, asname = import_names
58                    name = asname or qname
59
60            if _has_locals_call_after_node(stmt, node.scope()):
61                message_name = "possibly-unused-variable"
62            else:
63                if isinstance(stmt, nodes.Import):
64                    if asname is not None:
65                        msg = f"{qname} imported as {asname}"
66                    else:
67                        msg = f"import {name}"
68                    self.add_message("unused-import", args=msg, node=stmt)
69                    return
70                if isinstance(stmt, nodes.ImportFrom):
71                    if asname is not None:
72                        msg = f"{qname} imported from {stmt.modname} as {asname}"
73                    else:
74                        msg = f"{name} imported from {stmt.modname}"
75                    self.add_message("unused-import", args=msg, node=stmt)
76                    return
77                message_name = "unused-variable"
78
79            if isinstance(stmt, nodes.FunctionDef) and stmt.decorators:
80                return
81
82            # Don't check function stubs created only for type information
83            if utils.is_overload_stub(node):
84                return
85
86            # Special case for exception variable
87            if isinstance(stmt.parent, nodes.ExceptHandler) and any(
88                n.name == name for n in stmt.parent.nodes_of_class(nodes.Name)
89            ):
90                return
91
92            self.add_message(message_name, args=name, node=stmt)
            

Path 6: 11 calls (0.01)

→ name 'e' (4) 'exc' (2) 'error' (2) 'chest' (1) 'test_redefined_in_except_handler' (1) 'CustomException' (1)

→ node FunctionDef (11)

→ stmt AssignName (10) FunctionDef (1)

→ global_names set() (11)

→ nonlocal_names set() (11)

→ comprehension_target_names set() (11)

22 run 32 not run

1def _check_is_unused(
2        self,
3        name: str,
4        node: nodes.FunctionDef,
5        stmt: nodes.NodeNG,
6        global_names: set[str],
7        nonlocal_names: Iterable[str],
8        comprehension_target_names: Iterable[str],
9    ) -> None:
10        # Ignore some special names specified by user configuration.
11        if self._is_name_ignored(stmt, name):
12            return
13        # Ignore names that were added dynamically to the Function scope
14        if (
15            isinstance(node, nodes.FunctionDef)
16            and name == "__class__"
17            and len(node.locals["__class__"]) == 1
18            and isinstance(node.locals["__class__"][0], nodes.ClassDef)
19        ):
20            return
21
22        # Ignore names imported by the global statement.
23        if isinstance(stmt, (nodes.Global, nodes.Import, nodes.ImportFrom)):
24            # Detect imports, assigned to global statements.
25            if global_names and _import_name_is_global(stmt, global_names):
26                return
27
28        # Ignore names in comprehension targets
29        if name in comprehension_target_names:
30            return
31
32        # Ignore names in string literal type annotation.
33        if name in self._type_annotation_names:
34            return
35
36        argnames = node.argnames()
37        # Care about functions with unknown argument (builtins)
38        if name in argnames:
39            self._check_unused_arguments(name, node, stmt, argnames, nonlocal_names)
40        else:
41            if stmt.parent and isinstance(
42                stmt.parent, (nodes.Assign, nodes.AnnAssign, nodes.Tuple, nodes.For)
43            ):
44                if name in nonlocal_names:
45                    return
46
47            qname = asname = None
48            if isinstance(stmt, (nodes.Import, nodes.ImportFrom)):
49                # Need the complete name, which we don't have in .locals.
50                if len(stmt.names) > 1:
51                    import_names = next(
52                        (names for names in stmt.names if name in names), None
53                    )
54                else:
55                    import_names = stmt.names[0]
56                if import_names:
57                    qname, asname = import_names
58                    name = asname or qname
59
60            if _has_locals_call_after_node(stmt, node.scope()):
61                message_name = "possibly-unused-variable"
62            else:
63                if isinstance(stmt, nodes.Import):
64                    if asname is not None:
65                        msg = f"{qname} imported as {asname}"
66                    else:
67                        msg = f"import {name}"
68                    self.add_message("unused-import", args=msg, node=stmt)
69                    return
70                if isinstance(stmt, nodes.ImportFrom):
71                    if asname is not None:
72                        msg = f"{qname} imported from {stmt.modname} as {asname}"
73                    else:
74                        msg = f"{name} imported from {stmt.modname}"
75                    self.add_message("unused-import", args=msg, node=stmt)
76                    return
77                message_name = "unused-variable"
78
79            if isinstance(stmt, nodes.FunctionDef) and stmt.decorators:
80                return
81
82            # Don't check function stubs created only for type information
83            if utils.is_overload_stub(node):
84                return
85
86            # Special case for exception variable
87            if isinstance(stmt.parent, nodes.ExceptHandler) and any(
88                n.name == name for n in stmt.parent.nodes_of_class(nodes.Name)
89            ):
90                return
91
92            self.add_message(message_name, args=name, node=stmt)
            

Path 7: 9 calls (0.01)

→ name 'symtable' (1) 'trace' (1) 'tabnanny' (1) 'astroid' (1) 'notastroid' (1) 'xml' (1) 'unittest' (1) 'this' (1) 'x' (1)

→ node FunctionDef (9)

→ stmt Import (9)

→ global_names set() (8) {'deque', 'OS', 'PATH', 'collections'} (1)

→ nonlocal_names set() (9)

→ comprehension_target_names set() (9)

↩ return None (9)

25 run 29 not run

1def _check_is_unused(
2        self,
3        name: str,
4        node: nodes.FunctionDef,
5        stmt: nodes.NodeNG,
6        global_names: set[str],
7        nonlocal_names: Iterable[str],
8        comprehension_target_names: Iterable[str],
9    ) -> None:
10        # Ignore some special names specified by user configuration.
11        if self._is_name_ignored(stmt, name):
12            return
13        # Ignore names that were added dynamically to the Function scope
14        if (
15            isinstance(node, nodes.FunctionDef)
16            and name == "__class__"
17            and len(node.locals["__class__"]) == 1
18            and isinstance(node.locals["__class__"][0], nodes.ClassDef)
19        ):
20            return
21
22        # Ignore names imported by the global statement.
23        if isinstance(stmt, (nodes.Global, nodes.Import, nodes.ImportFrom)):
24            # Detect imports, assigned to global statements.
25            if global_names and _import_name_is_global(stmt, global_names):
26                return
27
28        # Ignore names in comprehension targets
29        if name in comprehension_target_names:
30            return
31
32        # Ignore names in string literal type annotation.
33        if name in self._type_annotation_names:
34            return
35
36        argnames = node.argnames()
37        # Care about functions with unknown argument (builtins)
38        if name in argnames:
39            self._check_unused_arguments(name, node, stmt, argnames, nonlocal_names)
40        else:
41            if stmt.parent and isinstance(
42                stmt.parent, (nodes.Assign, nodes.AnnAssign, nodes.Tuple, nodes.For)
43            ):
44                if name in nonlocal_names:
45                    return
46
47            qname = asname = None
48            if isinstance(stmt, (nodes.Import, nodes.ImportFrom)):
49                # Need the complete name, which we don't have in .locals.
50                if len(stmt.names) > 1:
51                    import_names = next(
52                        (names for names in stmt.names if name in names), None
53                    )
54                else:
55                    import_names = stmt.names[0]
56                if import_names:
57                    qname, asname = import_names
58                    name = asname or qname
59
60            if _has_locals_call_after_node(stmt, node.scope()):
61                message_name = "possibly-unused-variable"
62            else:
63                if isinstance(stmt, nodes.Import):
64                    if asname is not None:
65                        msg = f"{qname} imported as {asname}"
66                    else:
67                        msg = f"import {name}"
68                    self.add_message("unused-import", args=msg, node=stmt)
69                    return
70                if isinstance(stmt, nodes.ImportFrom):
71                    if asname is not None:
72                        msg = f"{qname} imported from {stmt.modname} as {asname}"
73                    else:
74                        msg = f"{name} imported from {stmt.modname}"
75                    self.add_message("unused-import", args=msg, node=stmt)
76                    return
77                message_name = "unused-variable"
78
79            if isinstance(stmt, nodes.FunctionDef) and stmt.decorators:
80                return
81
82            # Don't check function stubs created only for type information
83            if utils.is_overload_stub(node):
84                return
85
86            # Special case for exception variable
87            if isinstance(stmt.parent, nodes.ExceptHandler) and any(
88                n.name == name for n in stmt.parent.nodes_of_class(nodes.Name)
89            ):
90                return
91
92            self.add_message(message_name, args=name, node=stmt)
            

Path 8: 6 calls (0.0)

→ name 'sys' (1) 'namedtuple' (1) 'OS' (1) 'collections' (1) 'PATH' (1) 'deque' (1)

→ node FunctionDef (6)

→ stmt Import (3) ImportFrom (3)

→ global_names {'deque', 'OS', 'PATH', 'collections'} (4) {'sys'} (1) {'namedtuple'} (1)

→ nonlocal_names set() (6)

→ comprehension_target_names set() (6)

↩ return None (6)

7 run 47 not run

1def _check_is_unused(
2        self,
3        name: str,
4        node: nodes.FunctionDef,
5        stmt: nodes.NodeNG,
6        global_names: set[str],
7        nonlocal_names: Iterable[str],
8        comprehension_target_names: Iterable[str],
9    ) -> None:
10        # Ignore some special names specified by user configuration.
11        if self._is_name_ignored(stmt, name):
12            return
13        # Ignore names that were added dynamically to the Function scope
14        if (
15            isinstance(node, nodes.FunctionDef)
16            and name == "__class__"
17            and len(node.locals["__class__"]) == 1
18            and isinstance(node.locals["__class__"][0], nodes.ClassDef)
19        ):
20            return
21
22        # Ignore names imported by the global statement.
23        if isinstance(stmt, (nodes.Global, nodes.Import, nodes.ImportFrom)):
24            # Detect imports, assigned to global statements.
25            if global_names and _import_name_is_global(stmt, global_names):
26                return
27
28        # Ignore names in comprehension targets
29        if name in comprehension_target_names:
30            return
31
32        # Ignore names in string literal type annotation.
33        if name in self._type_annotation_names:
34            return
35
36        argnames = node.argnames()
37        # Care about functions with unknown argument (builtins)
38        if name in argnames:
39            self._check_unused_arguments(name, node, stmt, argnames, nonlocal_names)
40        else:
41            if stmt.parent and isinstance(
42                stmt.parent, (nodes.Assign, nodes.AnnAssign, nodes.Tuple, nodes.For)
43            ):
44                if name in nonlocal_names:
45                    return
46
47            qname = asname = None
48            if isinstance(stmt, (nodes.Import, nodes.ImportFrom)):
49                # Need the complete name, which we don't have in .locals.
50                if len(stmt.names) > 1:
51                    import_names = next(
52                        (names for names in stmt.names if name in names), None
53                    )
54                else:
55                    import_names = stmt.names[0]
56                if import_names:
57                    qname, asname = import_names
58                    name = asname or qname
59
60            if _has_locals_call_after_node(stmt, node.scope()):
61                message_name = "possibly-unused-variable"
62            else:
63                if isinstance(stmt, nodes.Import):
64                    if asname is not None:
65                        msg = f"{qname} imported as {asname}"
66                    else:
67                        msg = f"import {name}"
68                    self.add_message("unused-import", args=msg, node=stmt)
69                    return
70                if isinstance(stmt, nodes.ImportFrom):
71                    if asname is not None:
72                        msg = f"{qname} imported from {stmt.modname} as {asname}"
73                    else:
74                        msg = f"{name} imported from {stmt.modname}"
75                    self.add_message("unused-import", args=msg, node=stmt)
76                    return
77                message_name = "unused-variable"
78
79            if isinstance(stmt, nodes.FunctionDef) and stmt.decorators:
80                return
81
82            # Don't check function stubs created only for type information
83            if utils.is_overload_stub(node):
84                return
85
86            # Special case for exception variable
87            if isinstance(stmt.parent, nodes.ExceptHandler) and any(
88                n.name == name for n in stmt.parent.nodes_of_class(nodes.Name)
89            ):
90                return
91
92            self.add_message(message_name, args=name, node=stmt)
            

Path 9: 4 calls (0.0)

→ name 'defaultdict' (1) 'open' (1) 'namedtuple' (1) 'platform' (1)

→ node FunctionDef (4)

→ stmt ImportFrom (4)

→ global_names set() (3) {'deque', 'OS', 'PATH', 'collections'} (1)

→ nonlocal_names set() (4)

→ comprehension_target_names set() (4)

↩ return None (4)

26 run 28 not run

1def _check_is_unused(
2        self,
3        name: str,
4        node: nodes.FunctionDef,
5        stmt: nodes.NodeNG,
6        global_names: set[str],
7        nonlocal_names: Iterable[str],
8        comprehension_target_names: Iterable[str],
9    ) -> None:
10        # Ignore some special names specified by user configuration.
11        if self._is_name_ignored(stmt, name):
12            return
13        # Ignore names that were added dynamically to the Function scope
14        if (
15            isinstance(node, nodes.FunctionDef)
16            and name == "__class__"
17            and len(node.locals["__class__"]) == 1
18            and isinstance(node.locals["__class__"][0], nodes.ClassDef)
19        ):
20            return
21
22        # Ignore names imported by the global statement.
23        if isinstance(stmt, (nodes.Global, nodes.Import, nodes.ImportFrom)):
24            # Detect imports, assigned to global statements.
25            if global_names and _import_name_is_global(stmt, global_names):
26                return
27
28        # Ignore names in comprehension targets
29        if name in comprehension_target_names:
30            return
31
32        # Ignore names in string literal type annotation.
33        if name in self._type_annotation_names:
34            return
35
36        argnames = node.argnames()
37        # Care about functions with unknown argument (builtins)
38        if name in argnames:
39            self._check_unused_arguments(name, node, stmt, argnames, nonlocal_names)
40        else:
41            if stmt.parent and isinstance(
42                stmt.parent, (nodes.Assign, nodes.AnnAssign, nodes.Tuple, nodes.For)
43            ):
44                if name in nonlocal_names:
45                    return
46
47            qname = asname = None
48            if isinstance(stmt, (nodes.Import, nodes.ImportFrom)):
49                # Need the complete name, which we don't have in .locals.
50                if len(stmt.names) > 1:
51                    import_names = next(
52                        (names for names in stmt.names if name in names), None
53                    )
54                else:
55                    import_names = stmt.names[0]
56                if import_names:
57                    qname, asname = import_names
58                    name = asname or qname
59
60            if _has_locals_call_after_node(stmt, node.scope()):
61                message_name = "possibly-unused-variable"
62            else:
63                if isinstance(stmt, nodes.Import):
64                    if asname is not None:
65                        msg = f"{qname} imported as {asname}"
66                    else:
67                        msg = f"import {name}"
68                    self.add_message("unused-import", args=msg, node=stmt)
69                    return
70                if isinstance(stmt, nodes.ImportFrom):
71                    if asname is not None:
72                        msg = f"{qname} imported from {stmt.modname} as {asname}"
73                    else:
74                        msg = f"{name} imported from {stmt.modname}"
75                    self.add_message("unused-import", args=msg, node=stmt)
76                    return
77                message_name = "unused-variable"
78
79            if isinstance(stmt, nodes.FunctionDef) and stmt.decorators:
80                return
81
82            # Don't check function stubs created only for type information
83            if utils.is_overload_stub(node):
84                return
85
86            # Special case for exception variable
87            if isinstance(stmt.parent, nodes.ExceptHandler) and any(
88                n.name == name for n in stmt.parent.nodes_of_class(nodes.Name)
89            ):
90                return
91
92            self.add_message(message_name, args=name, node=stmt)
            

Path 10: 4 calls (0.0)

→ name 'key' (2) 'my_int' (1) 'x' (1)

→ node FunctionDef (4)

→ stmt AssignName (4)

→ global_names set() (4)

→ nonlocal_names set() (4)

→ comprehension_target_names {'my_int'} (1) {'value', 'key'} (1) {'b', 'a', 'key'} (1) {'x'} (1)

↩ return None (4)

7 run 47 not run

1def _check_is_unused(
2        self,
3        name: str,
4        node: nodes.FunctionDef,
5        stmt: nodes.NodeNG,
6        global_names: set[str],
7        nonlocal_names: Iterable[str],
8        comprehension_target_names: Iterable[str],
9    ) -> None:
10        # Ignore some special names specified by user configuration.
11        if self._is_name_ignored(stmt, name):
12            return
13        # Ignore names that were added dynamically to the Function scope
14        if (
15            isinstance(node, nodes.FunctionDef)
16            and name == "__class__"
17            and len(node.locals["__class__"]) == 1
18            and isinstance(node.locals["__class__"][0], nodes.ClassDef)
19        ):
20            return
21
22        # Ignore names imported by the global statement.
23        if isinstance(stmt, (nodes.Global, nodes.Import, nodes.ImportFrom)):
24            # Detect imports, assigned to global statements.
25            if global_names and _import_name_is_global(stmt, global_names):
26                return
27
28        # Ignore names in comprehension targets
29        if name in comprehension_target_names:
30            return
31
32        # Ignore names in string literal type annotation.
33        if name in self._type_annotation_names:
34            return
35
36        argnames = node.argnames()
37        # Care about functions with unknown argument (builtins)
38        if name in argnames:
39            self._check_unused_arguments(name, node, stmt, argnames, nonlocal_names)
40        else:
41            if stmt.parent and isinstance(
42                stmt.parent, (nodes.Assign, nodes.AnnAssign, nodes.Tuple, nodes.For)
43            ):
44                if name in nonlocal_names:
45                    return
46
47            qname = asname = None
48            if isinstance(stmt, (nodes.Import, nodes.ImportFrom)):
49                # Need the complete name, which we don't have in .locals.
50                if len(stmt.names) > 1:
51                    import_names = next(
52                        (names for names in stmt.names if name in names), None
53                    )
54                else:
55                    import_names = stmt.names[0]
56                if import_names:
57                    qname, asname = import_names
58                    name = asname or qname
59
60            if _has_locals_call_after_node(stmt, node.scope()):
61                message_name = "possibly-unused-variable"
62            else:
63                if isinstance(stmt, nodes.Import):
64                    if asname is not None:
65                        msg = f"{qname} imported as {asname}"
66                    else:
67                        msg = f"import {name}"
68                    self.add_message("unused-import", args=msg, node=stmt)
69                    return
70                if isinstance(stmt, nodes.ImportFrom):
71                    if asname is not None:
72                        msg = f"{qname} imported from {stmt.modname} as {asname}"
73                    else:
74                        msg = f"{name} imported from {stmt.modname}"
75                    self.add_message("unused-import", args=msg, node=stmt)
76                    return
77                message_name = "unused-variable"
78
79            if isinstance(stmt, nodes.FunctionDef) and stmt.decorators:
80                return
81
82            # Don't check function stubs created only for type information
83            if utils.is_overload_stub(node):
84                return
85
86            # Special case for exception variable
87            if isinstance(stmt.parent, nodes.ExceptHandler) and any(
88                n.name == name for n in stmt.parent.nodes_of_class(nodes.Name)
89            ):
90                return
91
92            self.add_message(message_name, args=name, node=stmt)
            

Path 11: 3 calls (0.0)

→ name 'thyme' (1) 'sql' (1) 'RE' (1)

→ node FunctionDef (3)

→ stmt Import (3)

→ global_names set() (2) {'deque', 'OS', 'PATH', 'collections'} (1)

→ nonlocal_names set() (3)

→ comprehension_target_names set() (3)

↩ return None (3)

25 run 29 not run

1def _check_is_unused(
2        self,
3        name: str,
4        node: nodes.FunctionDef,
5        stmt: nodes.NodeNG,
6        global_names: set[str],
7        nonlocal_names: Iterable[str],
8        comprehension_target_names: Iterable[str],
9    ) -> None:
10        # Ignore some special names specified by user configuration.
11        if self._is_name_ignored(stmt, name):
12            return
13        # Ignore names that were added dynamically to the Function scope
14        if (
15            isinstance(node, nodes.FunctionDef)
16            and name == "__class__"
17            and len(node.locals["__class__"]) == 1
18            and isinstance(node.locals["__class__"][0], nodes.ClassDef)
19        ):
20            return
21
22        # Ignore names imported by the global statement.
23        if isinstance(stmt, (nodes.Global, nodes.Import, nodes.ImportFrom)):
24            # Detect imports, assigned to global statements.
25            if global_names and _import_name_is_global(stmt, global_names):
26                return
27
28        # Ignore names in comprehension targets
29        if name in comprehension_target_names:
30            return
31
32        # Ignore names in string literal type annotation.
33        if name in self._type_annotation_names:
34            return
35
36        argnames = node.argnames()
37        # Care about functions with unknown argument (builtins)
38        if name in argnames:
39            self._check_unused_arguments(name, node, stmt, argnames, nonlocal_names)
40        else:
41            if stmt.parent and isinstance(
42                stmt.parent, (nodes.Assign, nodes.AnnAssign, nodes.Tuple, nodes.For)
43            ):
44                if name in nonlocal_names:
45                    return
46
47            qname = asname = None
48            if isinstance(stmt, (nodes.Import, nodes.ImportFrom)):
49                # Need the complete name, which we don't have in .locals.
50                if len(stmt.names) > 1:
51                    import_names = next(
52                        (names for names in stmt.names if name in names), None
53                    )
54                else:
55                    import_names = stmt.names[0]
56                if import_names:
57                    qname, asname = import_names
58                    name = asname or qname
59
60            if _has_locals_call_after_node(stmt, node.scope()):
61                message_name = "possibly-unused-variable"
62            else:
63                if isinstance(stmt, nodes.Import):
64                    if asname is not None:
65                        msg = f"{qname} imported as {asname}"
66                    else:
67                        msg = f"import {name}"
68                    self.add_message("unused-import", args=msg, node=stmt)
69                    return
70                if isinstance(stmt, nodes.ImportFrom):
71                    if asname is not None:
72                        msg = f"{qname} imported from {stmt.modname} as {asname}"
73                    else:
74                        msg = f"{name} imported from {stmt.modname}"
75                    self.add_message("unused-import", args=msg, node=stmt)
76                    return
77                message_name = "unused-variable"
78
79            if isinstance(stmt, nodes.FunctionDef) and stmt.decorators:
80                return
81
82            # Don't check function stubs created only for type information
83            if utils.is_overload_stub(node):
84                return
85
86            # Special case for exception variable
87            if isinstance(stmt.parent, nodes.ExceptHandler) and any(
88                n.name == name for n in stmt.parent.nodes_of_class(nodes.Name)
89            ):
90                return
91
92            self.add_message(message_name, args=name, node=stmt)
            

Path 12: 2 calls (0.0)

→ name 'os' (1) 'sys' (1)

→ node FunctionDef (2)

→ stmt Import (2)

→ global_names set() (2)

→ nonlocal_names set() (2)

→ comprehension_target_names set() (2)

↩ return None (2)

⚠ exception GeneratorExit (2)

26 run 28 not run

1def _check_is_unused(
2        self,
3        name: str,
4        node: nodes.FunctionDef,
5        stmt: nodes.NodeNG,
6        global_names: set[str],
7        nonlocal_names: Iterable[str],
8        comprehension_target_names: Iterable[str],
9    ) -> None:
10        # Ignore some special names specified by user configuration.
11        if self._is_name_ignored(stmt, name):
12            return
13        # Ignore names that were added dynamically to the Function scope
14        if (
15            isinstance(node, nodes.FunctionDef)
16            and name == "__class__"
17            and len(node.locals["__class__"]) == 1
18            and isinstance(node.locals["__class__"][0], nodes.ClassDef)
19        ):
20            return
21
22        # Ignore names imported by the global statement.
23        if isinstance(stmt, (nodes.Global, nodes.Import, nodes.ImportFrom)):
24            # Detect imports, assigned to global statements.
25            if global_names and _import_name_is_global(stmt, global_names):
26                return
27
28        # Ignore names in comprehension targets
29        if name in comprehension_target_names:
30            return
31
32        # Ignore names in string literal type annotation.
33        if name in self._type_annotation_names:
34            return
35
36        argnames = node.argnames()
37        # Care about functions with unknown argument (builtins)
38        if name in argnames:
39            self._check_unused_arguments(name, node, stmt, argnames, nonlocal_names)
40        else:
41            if stmt.parent and isinstance(
42                stmt.parent, (nodes.Assign, nodes.AnnAssign, nodes.Tuple, nodes.For)
43            ):
44                if name in nonlocal_names:
45                    return
46
47            qname = asname = None
48            if isinstance(stmt, (nodes.Import, nodes.ImportFrom)):
49                # Need the complete name, which we don't have in .locals.
50                if len(stmt.names) > 1:
51                    import_names = next(
52                        (names for names in stmt.names if name in names), None
53                    )
54                else:
55                    import_names = stmt.names[0]
56                if import_names:
57                    qname, asname = import_names
58                    name = asname or qname
59
60            if _has_locals_call_after_node(stmt, node.scope()):
61                message_name = "possibly-unused-variable"
62            else:
63                if isinstance(stmt, nodes.Import):
64                    if asname is not None:
65                        msg = f"{qname} imported as {asname}"
66                    else:
67                        msg = f"import {name}"
68                    self.add_message("unused-import", args=msg, node=stmt)
69                    return
70                if isinstance(stmt, nodes.ImportFrom):
71                    if asname is not None:
72                        msg = f"{qname} imported from {stmt.modname} as {asname}"
73                    else:
74                        msg = f"{name} imported from {stmt.modname}"
75                    self.add_message("unused-import", args=msg, node=stmt)
76                    return
77                message_name = "unused-variable"
78
79            if isinstance(stmt, nodes.FunctionDef) and stmt.decorators:
80                return
81
82            # Don't check function stubs created only for type information
83            if utils.is_overload_stub(node):
84                return
85
86            # Special case for exception variable
87            if isinstance(stmt.parent, nodes.ExceptHandler) and any(
88                n.name == name for n in stmt.parent.nodes_of_class(nodes.Name)
89            ):
90                return
91
92            self.add_message(message_name, args=name, node=stmt)
            

Path 13: 2 calls (0.0)

→ name 'rand' (1) 'sock' (1)

→ node FunctionDef (2)

→ stmt Import (2)

→ global_names set() (2)

→ nonlocal_names set() (2)

→ comprehension_target_names set() (2)

↩ return None (2)

⚠ exception GeneratorExit (2)

26 run 28 not run

1def _check_is_unused(
2        self,
3        name: str,
4        node: nodes.FunctionDef,
5        stmt: nodes.NodeNG,
6        global_names: set[str],
7        nonlocal_names: Iterable[str],
8        comprehension_target_names: Iterable[str],
9    ) -> None:
10        # Ignore some special names specified by user configuration.
11        if self._is_name_ignored(stmt, name):
12            return
13        # Ignore names that were added dynamically to the Function scope
14        if (
15            isinstance(node, nodes.FunctionDef)
16            and name == "__class__"
17            and len(node.locals["__class__"]) == 1
18            and isinstance(node.locals["__class__"][0], nodes.ClassDef)
19        ):
20            return
21
22        # Ignore names imported by the global statement.
23        if isinstance(stmt, (nodes.Global, nodes.Import, nodes.ImportFrom)):
24            # Detect imports, assigned to global statements.
25            if global_names and _import_name_is_global(stmt, global_names):
26                return
27
28        # Ignore names in comprehension targets
29        if name in comprehension_target_names:
30            return
31
32        # Ignore names in string literal type annotation.
33        if name in self._type_annotation_names:
34            return
35
36        argnames = node.argnames()
37        # Care about functions with unknown argument (builtins)
38        if name in argnames:
39            self._check_unused_arguments(name, node, stmt, argnames, nonlocal_names)
40        else:
41            if stmt.parent and isinstance(
42                stmt.parent, (nodes.Assign, nodes.AnnAssign, nodes.Tuple, nodes.For)
43            ):
44                if name in nonlocal_names:
45                    return
46
47            qname = asname = None
48            if isinstance(stmt, (nodes.Import, nodes.ImportFrom)):
49                # Need the complete name, which we don't have in .locals.
50                if len(stmt.names) > 1:
51                    import_names = next(
52                        (names for names in stmt.names if name in names), None
53                    )
54                else:
55                    import_names = stmt.names[0]
56                if import_names:
57                    qname, asname = import_names
58                    name = asname or qname
59
60            if _has_locals_call_after_node(stmt, node.scope()):
61                message_name = "possibly-unused-variable"
62            else:
63                if isinstance(stmt, nodes.Import):
64                    if asname is not None:
65                        msg = f"{qname} imported as {asname}"
66                    else:
67                        msg = f"import {name}"
68                    self.add_message("unused-import", args=msg, node=stmt)
69                    return
70                if isinstance(stmt, nodes.ImportFrom):
71                    if asname is not None:
72                        msg = f"{qname} imported from {stmt.modname} as {asname}"
73                    else:
74                        msg = f"{name} imported from {stmt.modname}"
75                    self.add_message("unused-import", args=msg, node=stmt)
76                    return
77                message_name = "unused-variable"
78
79            if isinstance(stmt, nodes.FunctionDef) and stmt.decorators:
80                return
81
82            # Don't check function stubs created only for type information
83            if utils.is_overload_stub(node):
84                return
85
86            # Special case for exception variable
87            if isinstance(stmt.parent, nodes.ExceptHandler) and any(
88                n.name == name for n in stmt.parent.nodes_of_class(nodes.Name)
89            ):
90                return
91
92            self.add_message(message_name, args=name, node=stmt)
            

Path 14: 2 calls (0.0)

→ name 'sign' (1) 'cosplay' (1)

→ node FunctionDef (2)

→ stmt ImportFrom (2)

→ global_names set() (2)

→ nonlocal_names set() (2)

→ comprehension_target_names set() (2)

↩ return None (2)

⚠ exception GeneratorExit (2)

27 run 27 not run

1def _check_is_unused(
2        self,
3        name: str,
4        node: nodes.FunctionDef,
5        stmt: nodes.NodeNG,
6        global_names: set[str],
7        nonlocal_names: Iterable[str],
8        comprehension_target_names: Iterable[str],
9    ) -> None:
10        # Ignore some special names specified by user configuration.
11        if self._is_name_ignored(stmt, name):
12            return
13        # Ignore names that were added dynamically to the Function scope
14        if (
15            isinstance(node, nodes.FunctionDef)
16            and name == "__class__"
17            and len(node.locals["__class__"]) == 1
18            and isinstance(node.locals["__class__"][0], nodes.ClassDef)
19        ):
20            return
21
22        # Ignore names imported by the global statement.
23        if isinstance(stmt, (nodes.Global, nodes.Import, nodes.ImportFrom)):
24            # Detect imports, assigned to global statements.
25            if global_names and _import_name_is_global(stmt, global_names):
26                return
27
28        # Ignore names in comprehension targets
29        if name in comprehension_target_names:
30            return
31
32        # Ignore names in string literal type annotation.
33        if name in self._type_annotation_names:
34            return
35
36        argnames = node.argnames()
37        # Care about functions with unknown argument (builtins)
38        if name in argnames:
39            self._check_unused_arguments(name, node, stmt, argnames, nonlocal_names)
40        else:
41            if stmt.parent and isinstance(
42                stmt.parent, (nodes.Assign, nodes.AnnAssign, nodes.Tuple, nodes.For)
43            ):
44                if name in nonlocal_names:
45                    return
46
47            qname = asname = None
48            if isinstance(stmt, (nodes.Import, nodes.ImportFrom)):
49                # Need the complete name, which we don't have in .locals.
50                if len(stmt.names) > 1:
51                    import_names = next(
52                        (names for names in stmt.names if name in names), None
53                    )
54                else:
55                    import_names = stmt.names[0]
56                if import_names:
57                    qname, asname = import_names
58                    name = asname or qname
59
60            if _has_locals_call_after_node(stmt, node.scope()):
61                message_name = "possibly-unused-variable"
62            else:
63                if isinstance(stmt, nodes.Import):
64                    if asname is not None:
65                        msg = f"{qname} imported as {asname}"
66                    else:
67                        msg = f"import {name}"
68                    self.add_message("unused-import", args=msg, node=stmt)
69                    return
70                if isinstance(stmt, nodes.ImportFrom):
71                    if asname is not None:
72                        msg = f"{qname} imported from {stmt.modname} as {asname}"
73                    else:
74                        msg = f"{name} imported from {stmt.modname}"
75                    self.add_message("unused-import", args=msg, node=stmt)
76                    return
77                message_name = "unused-variable"
78
79            if isinstance(stmt, nodes.FunctionDef) and stmt.decorators:
80                return
81
82            # Don't check function stubs created only for type information
83            if utils.is_overload_stub(node):
84                return
85
86            # Special case for exception variable
87            if isinstance(stmt.parent, nodes.ExceptHandler) and any(
88                n.name == name for n in stmt.parent.nodes_of_class(nodes.Name)
89            ):
90                return
91
92            self.add_message(message_name, args=name, node=stmt)
            

Path 15: 2 calls (0.0)

→ name 'abc' (1) 'VERSION' (1)

→ node FunctionDef (2)

→ stmt ImportFrom (2)

→ global_names set() (1) {'deque', 'OS', 'PATH', 'collections'} (1)

→ nonlocal_names set() (2)

→ comprehension_target_names set() (2)

↩ return None (2)

26 run 28 not run

1def _check_is_unused(
2        self,
3        name: str,
4        node: nodes.FunctionDef,
5        stmt: nodes.NodeNG,
6        global_names: set[str],
7        nonlocal_names: Iterable[str],
8        comprehension_target_names: Iterable[str],
9    ) -> None:
10        # Ignore some special names specified by user configuration.
11        if self._is_name_ignored(stmt, name):
12            return
13        # Ignore names that were added dynamically to the Function scope
14        if (
15            isinstance(node, nodes.FunctionDef)
16            and name == "__class__"
17            and len(node.locals["__class__"]) == 1
18            and isinstance(node.locals["__class__"][0], nodes.ClassDef)
19        ):
20            return
21
22        # Ignore names imported by the global statement.
23        if isinstance(stmt, (nodes.Global, nodes.Import, nodes.ImportFrom)):
24            # Detect imports, assigned to global statements.
25            if global_names and _import_name_is_global(stmt, global_names):
26                return
27
28        # Ignore names in comprehension targets
29        if name in comprehension_target_names:
30            return
31
32        # Ignore names in string literal type annotation.
33        if name in self._type_annotation_names:
34            return
35
36        argnames = node.argnames()
37        # Care about functions with unknown argument (builtins)
38        if name in argnames:
39            self._check_unused_arguments(name, node, stmt, argnames, nonlocal_names)
40        else:
41            if stmt.parent and isinstance(
42                stmt.parent, (nodes.Assign, nodes.AnnAssign, nodes.Tuple, nodes.For)
43            ):
44                if name in nonlocal_names:
45                    return
46
47            qname = asname = None
48            if isinstance(stmt, (nodes.Import, nodes.ImportFrom)):
49                # Need the complete name, which we don't have in .locals.
50                if len(stmt.names) > 1:
51                    import_names = next(
52                        (names for names in stmt.names if name in names), None
53                    )
54                else:
55                    import_names = stmt.names[0]
56                if import_names:
57                    qname, asname = import_names
58                    name = asname or qname
59
60            if _has_locals_call_after_node(stmt, node.scope()):
61                message_name = "possibly-unused-variable"
62            else:
63                if isinstance(stmt, nodes.Import):
64                    if asname is not None:
65                        msg = f"{qname} imported as {asname}"
66                    else:
67                        msg = f"import {name}"
68                    self.add_message("unused-import", args=msg, node=stmt)
69                    return
70                if isinstance(stmt, nodes.ImportFrom):
71                    if asname is not None:
72                        msg = f"{qname} imported from {stmt.modname} as {asname}"
73                    else:
74                        msg = f"{name} imported from {stmt.modname}"
75                    self.add_message("unused-import", args=msg, node=stmt)
76                    return
77                message_name = "unused-variable"
78
79            if isinstance(stmt, nodes.FunctionDef) and stmt.decorators:
80                return
81
82            # Don't check function stubs created only for type information
83            if utils.is_overload_stub(node):
84                return
85
86            # Special case for exception variable
87            if isinstance(stmt.parent, nodes.ExceptHandler) and any(
88                n.name == name for n in stmt.parent.nodes_of_class(nodes.Name)
89            ):
90                return
91
92            self.add_message(message_name, args=name, node=stmt)
            

Path 16: 1 calls (0.0)

→ name 'bar' (1)

→ node FunctionDef (1)

→ stmt FunctionDef (1)

→ global_names set() (1)

→ nonlocal_names set() (1)

→ comprehension_target_names set() (1)

↩ return None (1)

19 run 35 not run

1def _check_is_unused(
2        self,
3        name: str,
4        node: nodes.FunctionDef,
5        stmt: nodes.NodeNG,
6        global_names: set[str],
7        nonlocal_names: Iterable[str],
8        comprehension_target_names: Iterable[str],
9    ) -> None:
10        # Ignore some special names specified by user configuration.
11        if self._is_name_ignored(stmt, name):
12            return
13        # Ignore names that were added dynamically to the Function scope
14        if (
15            isinstance(node, nodes.FunctionDef)
16            and name == "__class__"
17            and len(node.locals["__class__"]) == 1
18            and isinstance(node.locals["__class__"][0], nodes.ClassDef)
19        ):
20            return
21
22        # Ignore names imported by the global statement.
23        if isinstance(stmt, (nodes.Global, nodes.Import, nodes.ImportFrom)):
24            # Detect imports, assigned to global statements.
25            if global_names and _import_name_is_global(stmt, global_names):
26                return
27
28        # Ignore names in comprehension targets
29        if name in comprehension_target_names:
30            return
31
32        # Ignore names in string literal type annotation.
33        if name in self._type_annotation_names:
34            return
35
36        argnames = node.argnames()
37        # Care about functions with unknown argument (builtins)
38        if name in argnames:
39            self._check_unused_arguments(name, node, stmt, argnames, nonlocal_names)
40        else:
41            if stmt.parent and isinstance(
42                stmt.parent, (nodes.Assign, nodes.AnnAssign, nodes.Tuple, nodes.For)
43            ):
44                if name in nonlocal_names:
45                    return
46
47            qname = asname = None
48            if isinstance(stmt, (nodes.Import, nodes.ImportFrom)):
49                # Need the complete name, which we don't have in .locals.
50                if len(stmt.names) > 1:
51                    import_names = next(
52                        (names for names in stmt.names if name in names), None
53                    )
54                else:
55                    import_names = stmt.names[0]
56                if import_names:
57                    qname, asname = import_names
58                    name = asname or qname
59
60            if _has_locals_call_after_node(stmt, node.scope()):
61                message_name = "possibly-unused-variable"
62            else:
63                if isinstance(stmt, nodes.Import):
64                    if asname is not None:
65                        msg = f"{qname} imported as {asname}"
66                    else:
67                        msg = f"import {name}"
68                    self.add_message("unused-import", args=msg, node=stmt)
69                    return
70                if isinstance(stmt, nodes.ImportFrom):
71                    if asname is not None:
72                        msg = f"{qname} imported from {stmt.modname} as {asname}"
73                    else:
74                        msg = f"{name} imported from {stmt.modname}"
75                    self.add_message("unused-import", args=msg, node=stmt)
76                    return
77                message_name = "unused-variable"
78
79            if isinstance(stmt, nodes.FunctionDef) and stmt.decorators:
80                return
81
82            # Don't check function stubs created only for type information
83            if utils.is_overload_stub(node):
84                return
85
86            # Special case for exception variable
87            if isinstance(stmt.parent, nodes.ExceptHandler) and any(
88                n.name == name for n in stmt.parent.nodes_of_class(nodes.Name)
89            ):
90                return
91
92            self.add_message(message_name, args=name, node=stmt)
            

Path 17: 1 calls (0.0)

→ name 'Example' (1)

→ node FunctionDef (1)

→ stmt AssignName (1)

→ global_names set() (1)

→ nonlocal_names set() (1)

→ comprehension_target_names set() (1)

↩ return None (1)

8 run 46 not run

1def _check_is_unused(
2        self,
3        name: str,
4        node: nodes.FunctionDef,
5        stmt: nodes.NodeNG,
6        global_names: set[str],
7        nonlocal_names: Iterable[str],
8        comprehension_target_names: Iterable[str],
9    ) -> None:
10        # Ignore some special names specified by user configuration.
11        if self._is_name_ignored(stmt, name):
12            return
13        # Ignore names that were added dynamically to the Function scope
14        if (
15            isinstance(node, nodes.FunctionDef)
16            and name == "__class__"
17            and len(node.locals["__class__"]) == 1
18            and isinstance(node.locals["__class__"][0], nodes.ClassDef)
19        ):
20            return
21
22        # Ignore names imported by the global statement.
23        if isinstance(stmt, (nodes.Global, nodes.Import, nodes.ImportFrom)):
24            # Detect imports, assigned to global statements.
25            if global_names and _import_name_is_global(stmt, global_names):
26                return
27
28        # Ignore names in comprehension targets
29        if name in comprehension_target_names:
30            return
31
32        # Ignore names in string literal type annotation.
33        if name in self._type_annotation_names:
34            return
35
36        argnames = node.argnames()
37        # Care about functions with unknown argument (builtins)
38        if name in argnames:
39            self._check_unused_arguments(name, node, stmt, argnames, nonlocal_names)
40        else:
41            if stmt.parent and isinstance(
42                stmt.parent, (nodes.Assign, nodes.AnnAssign, nodes.Tuple, nodes.For)
43            ):
44                if name in nonlocal_names:
45                    return
46
47            qname = asname = None
48            if isinstance(stmt, (nodes.Import, nodes.ImportFrom)):
49                # Need the complete name, which we don't have in .locals.
50                if len(stmt.names) > 1:
51                    import_names = next(
52                        (names for names in stmt.names if name in names), None
53                    )
54                else:
55                    import_names = stmt.names[0]
56                if import_names:
57                    qname, asname = import_names
58                    name = asname or qname
59
60            if _has_locals_call_after_node(stmt, node.scope()):
61                message_name = "possibly-unused-variable"
62            else:
63                if isinstance(stmt, nodes.Import):
64                    if asname is not None:
65                        msg = f"{qname} imported as {asname}"
66                    else:
67                        msg = f"import {name}"
68                    self.add_message("unused-import", args=msg, node=stmt)
69                    return
70                if isinstance(stmt, nodes.ImportFrom):
71                    if asname is not None:
72                        msg = f"{qname} imported from {stmt.modname} as {asname}"
73                    else:
74                        msg = f"{name} imported from {stmt.modname}"
75                    self.add_message("unused-import", args=msg, node=stmt)
76                    return
77                message_name = "unused-variable"
78
79            if isinstance(stmt, nodes.FunctionDef) and stmt.decorators:
80                return
81
82            # Don't check function stubs created only for type information
83            if utils.is_overload_stub(node):
84                return
85
86            # Special case for exception variable
87            if isinstance(stmt.parent, nodes.ExceptHandler) and any(
88                n.name == name for n in stmt.parent.nodes_of_class(nodes.Name)
89            ):
90                return
91
92            self.add_message(message_name, args=name, node=stmt)
            

Path 18: 1 calls (0.0)

→ name '__class__' (1)

→ node FunctionDef (1)

→ stmt AssignName (1)

→ global_names set() (1)

→ nonlocal_names set() (1)

→ comprehension_target_names set() (1)

24 run 30 not run

1def _check_is_unused(
2        self,
3        name: str,
4        node: nodes.FunctionDef,
5        stmt: nodes.NodeNG,
6        global_names: set[str],
7        nonlocal_names: Iterable[str],
8        comprehension_target_names: Iterable[str],
9    ) -> None:
10        # Ignore some special names specified by user configuration.
11        if self._is_name_ignored(stmt, name):
12            return
13        # Ignore names that were added dynamically to the Function scope
14        if (
15            isinstance(node, nodes.FunctionDef)
16            and name == "__class__"
17            and len(node.locals["__class__"]) == 1
18            and isinstance(node.locals["__class__"][0], nodes.ClassDef)
19        ):
20            return
21
22        # Ignore names imported by the global statement.
23        if isinstance(stmt, (nodes.Global, nodes.Import, nodes.ImportFrom)):
24            # Detect imports, assigned to global statements.
25            if global_names and _import_name_is_global(stmt, global_names):
26                return
27
28        # Ignore names in comprehension targets
29        if name in comprehension_target_names:
30            return
31
32        # Ignore names in string literal type annotation.
33        if name in self._type_annotation_names:
34            return
35
36        argnames = node.argnames()
37        # Care about functions with unknown argument (builtins)
38        if name in argnames:
39            self._check_unused_arguments(name, node, stmt, argnames, nonlocal_names)
40        else:
41            if stmt.parent and isinstance(
42                stmt.parent, (nodes.Assign, nodes.AnnAssign, nodes.Tuple, nodes.For)
43            ):
44                if name in nonlocal_names:
45                    return
46
47            qname = asname = None
48            if isinstance(stmt, (nodes.Import, nodes.ImportFrom)):
49                # Need the complete name, which we don't have in .locals.
50                if len(stmt.names) > 1:
51                    import_names = next(
52                        (names for names in stmt.names if name in names), None
53                    )
54                else:
55                    import_names = stmt.names[0]
56                if import_names:
57                    qname, asname = import_names
58                    name = asname or qname
59
60            if _has_locals_call_after_node(stmt, node.scope()):
61                message_name = "possibly-unused-variable"
62            else:
63                if isinstance(stmt, nodes.Import):
64                    if asname is not None:
65                        msg = f"{qname} imported as {asname}"
66                    else:
67                        msg = f"import {name}"
68                    self.add_message("unused-import", args=msg, node=stmt)
69                    return
70                if isinstance(stmt, nodes.ImportFrom):
71                    if asname is not None:
72                        msg = f"{qname} imported from {stmt.modname} as {asname}"
73                    else:
74                        msg = f"{name} imported from {stmt.modname}"
75                    self.add_message("unused-import", args=msg, node=stmt)
76                    return
77                message_name = "unused-variable"
78
79            if isinstance(stmt, nodes.FunctionDef) and stmt.decorators:
80                return
81
82            # Don't check function stubs created only for type information
83            if utils.is_overload_stub(node):
84                return
85
86            # Special case for exception variable
87            if isinstance(stmt.parent, nodes.ExceptHandler) and any(
88                n.name == name for n in stmt.parent.nodes_of_class(nodes.Name)
89            ):
90                return
91
92            self.add_message(message_name, args=name, node=stmt)
            

Path 19: 1 calls (0.0)

→ name 'value' (1)

→ node FunctionDef (1)

→ stmt AssignName (1)

→ global_names set() (1)

→ nonlocal_names set() (1)

→ comprehension_target_names set() (1)

20 run 34 not run

1def _check_is_unused(
2        self,
3        name: str,
4        node: nodes.FunctionDef,
5        stmt: nodes.NodeNG,
6        global_names: set[str],
7        nonlocal_names: Iterable[str],
8        comprehension_target_names: Iterable[str],
9    ) -> None:
10        # Ignore some special names specified by user configuration.
11        if self._is_name_ignored(stmt, name):
12            return
13        # Ignore names that were added dynamically to the Function scope
14        if (
15            isinstance(node, nodes.FunctionDef)
16            and name == "__class__"
17            and len(node.locals["__class__"]) == 1
18            and isinstance(node.locals["__class__"][0], nodes.ClassDef)
19        ):
20            return
21
22        # Ignore names imported by the global statement.
23        if isinstance(stmt, (nodes.Global, nodes.Import, nodes.ImportFrom)):
24            # Detect imports, assigned to global statements.
25            if global_names and _import_name_is_global(stmt, global_names):
26                return
27
28        # Ignore names in comprehension targets
29        if name in comprehension_target_names:
30            return
31
32        # Ignore names in string literal type annotation.
33        if name in self._type_annotation_names:
34            return
35
36        argnames = node.argnames()
37        # Care about functions with unknown argument (builtins)
38        if name in argnames:
39            self._check_unused_arguments(name, node, stmt, argnames, nonlocal_names)
40        else:
41            if stmt.parent and isinstance(
42                stmt.parent, (nodes.Assign, nodes.AnnAssign, nodes.Tuple, nodes.For)
43            ):
44                if name in nonlocal_names:
45                    return
46
47            qname = asname = None
48            if isinstance(stmt, (nodes.Import, nodes.ImportFrom)):
49                # Need the complete name, which we don't have in .locals.
50                if len(stmt.names) > 1:
51                    import_names = next(
52                        (names for names in stmt.names if name in names), None
53                    )
54                else:
55                    import_names = stmt.names[0]
56                if import_names:
57                    qname, asname = import_names
58                    name = asname or qname
59
60            if _has_locals_call_after_node(stmt, node.scope()):
61                message_name = "possibly-unused-variable"
62            else:
63                if isinstance(stmt, nodes.Import):
64                    if asname is not None:
65                        msg = f"{qname} imported as {asname}"
66                    else:
67                        msg = f"import {name}"
68                    self.add_message("unused-import", args=msg, node=stmt)
69                    return
70                if isinstance(stmt, nodes.ImportFrom):
71                    if asname is not None:
72                        msg = f"{qname} imported from {stmt.modname} as {asname}"
73                    else:
74                        msg = f"{name} imported from {stmt.modname}"
75                    self.add_message("unused-import", args=msg, node=stmt)
76                    return
77                message_name = "unused-variable"
78
79            if isinstance(stmt, nodes.FunctionDef) and stmt.decorators:
80                return
81
82            # Don't check function stubs created only for type information
83            if utils.is_overload_stub(node):
84                return
85
86            # Special case for exception variable
87            if isinstance(stmt.parent, nodes.ExceptHandler) and any(
88                n.name == name for n in stmt.parent.nodes_of_class(nodes.Name)
89            ):
90                return
91
92            self.add_message(message_name, args=name, node=stmt)
            

Path 20: 1 calls (0.0)

→ name 'hexdigits' (1)

→ node FunctionDef (1)

→ stmt ImportFrom (1)

→ global_names set() (1)

→ nonlocal_names set() (1)

→ comprehension_target_names set() (1)

↩ return None (1)

⚠ exception GeneratorExit (1)

27 run 27 not run

1def _check_is_unused(
2        self,
3        name: str,
4        node: nodes.FunctionDef,
5        stmt: nodes.NodeNG,
6        global_names: set[str],
7        nonlocal_names: Iterable[str],
8        comprehension_target_names: Iterable[str],
9    ) -> None:
10        # Ignore some special names specified by user configuration.
11        if self._is_name_ignored(stmt, name):
12            return
13        # Ignore names that were added dynamically to the Function scope
14        if (
15            isinstance(node, nodes.FunctionDef)
16            and name == "__class__"
17            and len(node.locals["__class__"]) == 1
18            and isinstance(node.locals["__class__"][0], nodes.ClassDef)
19        ):
20            return
21
22        # Ignore names imported by the global statement.
23        if isinstance(stmt, (nodes.Global, nodes.Import, nodes.ImportFrom)):
24            # Detect imports, assigned to global statements.
25            if global_names and _import_name_is_global(stmt, global_names):
26                return
27
28        # Ignore names in comprehension targets
29        if name in comprehension_target_names:
30            return
31
32        # Ignore names in string literal type annotation.
33        if name in self._type_annotation_names:
34            return
35
36        argnames = node.argnames()
37        # Care about functions with unknown argument (builtins)
38        if name in argnames:
39            self._check_unused_arguments(name, node, stmt, argnames, nonlocal_names)
40        else:
41            if stmt.parent and isinstance(
42                stmt.parent, (nodes.Assign, nodes.AnnAssign, nodes.Tuple, nodes.For)
43            ):
44                if name in nonlocal_names:
45                    return
46
47            qname = asname = None
48            if isinstance(stmt, (nodes.Import, nodes.ImportFrom)):
49                # Need the complete name, which we don't have in .locals.
50                if len(stmt.names) > 1:
51                    import_names = next(
52                        (names for names in stmt.names if name in names), None
53                    )
54                else:
55                    import_names = stmt.names[0]
56                if import_names:
57                    qname, asname = import_names
58                    name = asname or qname
59
60            if _has_locals_call_after_node(stmt, node.scope()):
61                message_name = "possibly-unused-variable"
62            else:
63                if isinstance(stmt, nodes.Import):
64                    if asname is not None:
65                        msg = f"{qname} imported as {asname}"
66                    else:
67                        msg = f"import {name}"
68                    self.add_message("unused-import", args=msg, node=stmt)
69                    return
70                if isinstance(stmt, nodes.ImportFrom):
71                    if asname is not None:
72                        msg = f"{qname} imported from {stmt.modname} as {asname}"
73                    else:
74                        msg = f"{name} imported from {stmt.modname}"
75                    self.add_message("unused-import", args=msg, node=stmt)
76                    return
77                message_name = "unused-variable"
78
79            if isinstance(stmt, nodes.FunctionDef) and stmt.decorators:
80                return
81
82            # Don't check function stubs created only for type information
83            if utils.is_overload_stub(node):
84                return
85
86            # Special case for exception variable
87            if isinstance(stmt.parent, nodes.ExceptHandler) and any(
88                n.name == name for n in stmt.parent.nodes_of_class(nodes.Name)
89            ):
90                return
91
92            self.add_message(message_name, args=name, node=stmt)
            

Path 21: 1 calls (0.0)

→ name 'e' (1)

→ node FunctionDef (1)

→ stmt AssignName (1)

→ global_names set() (1)

→ nonlocal_names set() (1)

→ comprehension_target_names set() (1)

↩ return None (1)

⚠ exception GeneratorExit (1)

22 run 32 not run

1def _check_is_unused(
2        self,
3        name: str,
4        node: nodes.FunctionDef,
5        stmt: nodes.NodeNG,
6        global_names: set[str],
7        nonlocal_names: Iterable[str],
8        comprehension_target_names: Iterable[str],
9    ) -> None:
10        # Ignore some special names specified by user configuration.
11        if self._is_name_ignored(stmt, name):
12            return
13        # Ignore names that were added dynamically to the Function scope
14        if (
15            isinstance(node, nodes.FunctionDef)
16            and name == "__class__"
17            and len(node.locals["__class__"]) == 1
18            and isinstance(node.locals["__class__"][0], nodes.ClassDef)
19        ):
20            return
21
22        # Ignore names imported by the global statement.
23        if isinstance(stmt, (nodes.Global, nodes.Import, nodes.ImportFrom)):
24            # Detect imports, assigned to global statements.
25            if global_names and _import_name_is_global(stmt, global_names):
26                return
27
28        # Ignore names in comprehension targets
29        if name in comprehension_target_names:
30            return
31
32        # Ignore names in string literal type annotation.
33        if name in self._type_annotation_names:
34            return
35
36        argnames = node.argnames()
37        # Care about functions with unknown argument (builtins)
38        if name in argnames:
39            self._check_unused_arguments(name, node, stmt, argnames, nonlocal_names)
40        else:
41            if stmt.parent and isinstance(
42                stmt.parent, (nodes.Assign, nodes.AnnAssign, nodes.Tuple, nodes.For)
43            ):
44                if name in nonlocal_names:
45                    return
46
47            qname = asname = None
48            if isinstance(stmt, (nodes.Import, nodes.ImportFrom)):
49                # Need the complete name, which we don't have in .locals.
50                if len(stmt.names) > 1:
51                    import_names = next(
52                        (names for names in stmt.names if name in names), None
53                    )
54                else:
55                    import_names = stmt.names[0]
56                if import_names:
57                    qname, asname = import_names
58                    name = asname or qname
59
60            if _has_locals_call_after_node(stmt, node.scope()):
61                message_name = "possibly-unused-variable"
62            else:
63                if isinstance(stmt, nodes.Import):
64                    if asname is not None:
65                        msg = f"{qname} imported as {asname}"
66                    else:
67                        msg = f"import {name}"
68                    self.add_message("unused-import", args=msg, node=stmt)
69                    return
70                if isinstance(stmt, nodes.ImportFrom):
71                    if asname is not None:
72                        msg = f"{qname} imported from {stmt.modname} as {asname}"
73                    else:
74                        msg = f"{name} imported from {stmt.modname}"
75                    self.add_message("unused-import", args=msg, node=stmt)
76                    return
77                message_name = "unused-variable"
78
79            if isinstance(stmt, nodes.FunctionDef) and stmt.decorators:
80                return
81
82            # Don't check function stubs created only for type information
83            if utils.is_overload_stub(node):
84                return
85
86            # Special case for exception variable
87            if isinstance(stmt.parent, nodes.ExceptHandler) and any(
88                n.name == name for n in stmt.parent.nodes_of_class(nodes.Name)
89            ):
90                return
91
92            self.add_message(message_name, args=name, node=stmt)