Path 1: 8 calls (0.26)

Global (8) 

1@utils.only_required_for_messages(
2        "global-variable-undefined",
3        "global-variable-not-assigned",
4        "global-statement",
5        "global-at-module-level",
6        "redefined-builtin",
7    )
8    def visit_global(self, node: nodes.Global) -> None:
9        """Check names imported exists in the global scope."""
10        frame = node.frame(future=True)
11        if isinstance(frame, nodes.Module):
12            self.add_message("global-at-module-level", node=node, confidence=HIGH)
13            return
14
15        module = frame.root()
16        default_message = True
17        locals_ = node.scope().locals
18        for name in node.names:
19            try:
20                assign_nodes = module.getattr(name)
21            except astroid.NotFoundError:
22                # unassigned global, skip
23                assign_nodes = []
24
25            not_defined_locally_by_import = not any(
26                isinstance(local, (nodes.Import, nodes.ImportFrom))
27                for local in locals_.get(name, ())
28            )
29            if (
30                not utils.is_reassigned_after_current(node, name)
31                and not utils.is_deleted_after_current(node, name)
32                and not_defined_locally_by_import
33            ):
34                self.add_message(
35                    "global-variable-not-assigned",
36                    args=name,
37                    node=node,
38                    confidence=HIGH,
39                )
40                default_message = False
41                continue
42
43            for anode in assign_nodes:
44                if (
45                    isinstance(anode, nodes.AssignName)
46                    and anode.name in module.special_attributes
47                ):
48                    self.add_message("redefined-builtin", args=name, node=node)
49                    break
50                if anode.frame(future=True) is module:
51                    # module level assignment
52                    break
53                if (
54                    isinstance(anode, (nodes.ClassDef, nodes.FunctionDef))
55                    and anode.parent is module
56                ):
57                    # module level function assignment
58                    break
59            else:
60                if not_defined_locally_by_import:
61                    # global undefined at the module scope
62                    self.add_message(
63                        "global-variable-undefined",
64                        args=name,
65                        node=node,
66                        confidence=HIGH,
67                    )
68                    default_message = False
69
70        if default_message:
71            self.add_message("global-statement", node=node, confidence=HIGH)

Path 2: 7 calls (0.23)

Global (7) 

1@utils.only_required_for_messages(
2        "global-variable-undefined",
3        "global-variable-not-assigned",
4        "global-statement",
5        "global-at-module-level",
6        "redefined-builtin",
7    )
8    def visit_global(self, node: nodes.Global) -> None:
9        """Check names imported exists in the global scope."""
10        frame = node.frame(future=True)
11        if isinstance(frame, nodes.Module):
12            self.add_message("global-at-module-level", node=node, confidence=HIGH)
13            return
14
15        module = frame.root()
16        default_message = True
17        locals_ = node.scope().locals
18        for name in node.names:
19            try:
20                assign_nodes = module.getattr(name)
21            except astroid.NotFoundError:
22                # unassigned global, skip
23                assign_nodes = []
24
25            not_defined_locally_by_import = not any(
26                isinstance(local, (nodes.Import, nodes.ImportFrom))
27                for local in locals_.get(name, ())
28            )
29            if (
30                not utils.is_reassigned_after_current(node, name)
31                and not utils.is_deleted_after_current(node, name)
32                and not_defined_locally_by_import
33            ):
34                self.add_message(
35                    "global-variable-not-assigned",
36                    args=name,
37                    node=node,
38                    confidence=HIGH,
39                )
40                default_message = False
41                continue
42
43            for anode in assign_nodes:
44                if (
45                    isinstance(anode, nodes.AssignName)
46                    and anode.name in module.special_attributes
47                ):
48                    self.add_message("redefined-builtin", args=name, node=node)
49                    break
50                if anode.frame(future=True) is module:
51                    # module level assignment
52                    break
53                if (
54                    isinstance(anode, (nodes.ClassDef, nodes.FunctionDef))
55                    and anode.parent is module
56                ):
57                    # module level function assignment
58                    break
59            else:
60                if not_defined_locally_by_import:
61                    # global undefined at the module scope
62                    self.add_message(
63                        "global-variable-undefined",
64                        args=name,
65                        node=node,
66                        confidence=HIGH,
67                    )
68                    default_message = False
69
70        if default_message:
71            self.add_message("global-statement", node=node, confidence=HIGH)

Path 3: 5 calls (0.16)

Global (5)

AttributeInferenceError (5) 

1@utils.only_required_for_messages(
2        "global-variable-undefined",
3        "global-variable-not-assigned",
4        "global-statement",
5        "global-at-module-level",
6        "redefined-builtin",
7    )
8    def visit_global(self, node: nodes.Global) -> None:
9        """Check names imported exists in the global scope."""
10        frame = node.frame(future=True)
11        if isinstance(frame, nodes.Module):
12            self.add_message("global-at-module-level", node=node, confidence=HIGH)
13            return
14
15        module = frame.root()
16        default_message = True
17        locals_ = node.scope().locals
18        for name in node.names:
19            try:
20                assign_nodes = module.getattr(name)
21            except astroid.NotFoundError:
22                # unassigned global, skip
23                assign_nodes = []
24
25            not_defined_locally_by_import = not any(
26                isinstance(local, (nodes.Import, nodes.ImportFrom))
27                for local in locals_.get(name, ())
28            )
29            if (
30                not utils.is_reassigned_after_current(node, name)
31                and not utils.is_deleted_after_current(node, name)
32                and not_defined_locally_by_import
33            ):
34                self.add_message(
35                    "global-variable-not-assigned",
36                    args=name,
37                    node=node,
38                    confidence=HIGH,
39                )
40                default_message = False
41                continue
42
43            for anode in assign_nodes:
44                if (
45                    isinstance(anode, nodes.AssignName)
46                    and anode.name in module.special_attributes
47                ):
48                    self.add_message("redefined-builtin", args=name, node=node)
49                    break
50                if anode.frame(future=True) is module:
51                    # module level assignment
52                    break
53                if (
54                    isinstance(anode, (nodes.ClassDef, nodes.FunctionDef))
55                    and anode.parent is module
56                ):
57                    # module level function assignment
58                    break
59            else:
60                if not_defined_locally_by_import:
61                    # global undefined at the module scope
62                    self.add_message(
63                        "global-variable-undefined",
64                        args=name,
65                        node=node,
66                        confidence=HIGH,
67                    )
68                    default_message = False
69
70        if default_message:
71            self.add_message("global-statement", node=node, confidence=HIGH)

Path 4: 2 calls (0.06)

Global (2)

None (2) 

1@utils.only_required_for_messages(
2        "global-variable-undefined",
3        "global-variable-not-assigned",
4        "global-statement",
5        "global-at-module-level",
6        "redefined-builtin",
7    )
8    def visit_global(self, node: nodes.Global) -> None:
9        """Check names imported exists in the global scope."""
10        frame = node.frame(future=True)
11        if isinstance(frame, nodes.Module):
12            self.add_message("global-at-module-level", node=node, confidence=HIGH)
13            return
14
15        module = frame.root()
16        default_message = True
17        locals_ = node.scope().locals
18        for name in node.names:
19            try:
20                assign_nodes = module.getattr(name)
21            except astroid.NotFoundError:
22                # unassigned global, skip
23                assign_nodes = []
24
25            not_defined_locally_by_import = not any(
26                isinstance(local, (nodes.Import, nodes.ImportFrom))
27                for local in locals_.get(name, ())
28            )
29            if (
30                not utils.is_reassigned_after_current(node, name)
31                and not utils.is_deleted_after_current(node, name)
32                and not_defined_locally_by_import
33            ):
34                self.add_message(
35                    "global-variable-not-assigned",
36                    args=name,
37                    node=node,
38                    confidence=HIGH,
39                )
40                default_message = False
41                continue
42
43            for anode in assign_nodes:
44                if (
45                    isinstance(anode, nodes.AssignName)
46                    and anode.name in module.special_attributes
47                ):
48                    self.add_message("redefined-builtin", args=name, node=node)
49                    break
50                if anode.frame(future=True) is module:
51                    # module level assignment
52                    break
53                if (
54                    isinstance(anode, (nodes.ClassDef, nodes.FunctionDef))
55                    and anode.parent is module
56                ):
57                    # module level function assignment
58                    break
59            else:
60                if not_defined_locally_by_import:
61                    # global undefined at the module scope
62                    self.add_message(
63                        "global-variable-undefined",
64                        args=name,
65                        node=node,
66                        confidence=HIGH,
67                    )
68                    default_message = False
69
70        if default_message:
71            self.add_message("global-statement", node=node, confidence=HIGH)

Path 5: 2 calls (0.06)

Global (2)

GeneratorExit (2) 

1@utils.only_required_for_messages(
2        "global-variable-undefined",
3        "global-variable-not-assigned",
4        "global-statement",
5        "global-at-module-level",
6        "redefined-builtin",
7    )
8    def visit_global(self, node: nodes.Global) -> None:
9        """Check names imported exists in the global scope."""
10        frame = node.frame(future=True)
11        if isinstance(frame, nodes.Module):
12            self.add_message("global-at-module-level", node=node, confidence=HIGH)
13            return
14
15        module = frame.root()
16        default_message = True
17        locals_ = node.scope().locals
18        for name in node.names:
19            try:
20                assign_nodes = module.getattr(name)
21            except astroid.NotFoundError:
22                # unassigned global, skip
23                assign_nodes = []
24
25            not_defined_locally_by_import = not any(
26                isinstance(local, (nodes.Import, nodes.ImportFrom))
27                for local in locals_.get(name, ())
28            )
29            if (
30                not utils.is_reassigned_after_current(node, name)
31                and not utils.is_deleted_after_current(node, name)
32                and not_defined_locally_by_import
33            ):
34                self.add_message(
35                    "global-variable-not-assigned",
36                    args=name,
37                    node=node,
38                    confidence=HIGH,
39                )
40                default_message = False
41                continue
42
43            for anode in assign_nodes:
44                if (
45                    isinstance(anode, nodes.AssignName)
46                    and anode.name in module.special_attributes
47                ):
48                    self.add_message("redefined-builtin", args=name, node=node)
49                    break
50                if anode.frame(future=True) is module:
51                    # module level assignment
52                    break
53                if (
54                    isinstance(anode, (nodes.ClassDef, nodes.FunctionDef))
55                    and anode.parent is module
56                ):
57                    # module level function assignment
58                    break
59            else:
60                if not_defined_locally_by_import:
61                    # global undefined at the module scope
62                    self.add_message(
63                        "global-variable-undefined",
64                        args=name,
65                        node=node,
66                        confidence=HIGH,
67                    )
68                    default_message = False
69
70        if default_message:
71            self.add_message("global-statement", node=node, confidence=HIGH)

Path 6: 2 calls (0.06)

Global (2) 

1@utils.only_required_for_messages(
2        "global-variable-undefined",
3        "global-variable-not-assigned",
4        "global-statement",
5        "global-at-module-level",
6        "redefined-builtin",
7    )
8    def visit_global(self, node: nodes.Global) -> None:
9        """Check names imported exists in the global scope."""
10        frame = node.frame(future=True)
11        if isinstance(frame, nodes.Module):
12            self.add_message("global-at-module-level", node=node, confidence=HIGH)
13            return
14
15        module = frame.root()
16        default_message = True
17        locals_ = node.scope().locals
18        for name in node.names:
19            try:
20                assign_nodes = module.getattr(name)
21            except astroid.NotFoundError:
22                # unassigned global, skip
23                assign_nodes = []
24
25            not_defined_locally_by_import = not any(
26                isinstance(local, (nodes.Import, nodes.ImportFrom))
27                for local in locals_.get(name, ())
28            )
29            if (
30                not utils.is_reassigned_after_current(node, name)
31                and not utils.is_deleted_after_current(node, name)
32                and not_defined_locally_by_import
33            ):
34                self.add_message(
35                    "global-variable-not-assigned",
36                    args=name,
37                    node=node,
38                    confidence=HIGH,
39                )
40                default_message = False
41                continue
42
43            for anode in assign_nodes:
44                if (
45                    isinstance(anode, nodes.AssignName)
46                    and anode.name in module.special_attributes
47                ):
48                    self.add_message("redefined-builtin", args=name, node=node)
49                    break
50                if anode.frame(future=True) is module:
51                    # module level assignment
52                    break
53                if (
54                    isinstance(anode, (nodes.ClassDef, nodes.FunctionDef))
55                    and anode.parent is module
56                ):
57                    # module level function assignment
58                    break
59            else:
60                if not_defined_locally_by_import:
61                    # global undefined at the module scope
62                    self.add_message(
63                        "global-variable-undefined",
64                        args=name,
65                        node=node,
66                        confidence=HIGH,
67                    )
68                    default_message = False
69
70        if default_message:
71            self.add_message("global-statement", node=node, confidence=HIGH)

Path 7: 1 calls (0.03)

Global (1) 

1@utils.only_required_for_messages(
2        "global-variable-undefined",
3        "global-variable-not-assigned",
4        "global-statement",
5        "global-at-module-level",
6        "redefined-builtin",
7    )
8    def visit_global(self, node: nodes.Global) -> None:
9        """Check names imported exists in the global scope."""
10        frame = node.frame(future=True)
11        if isinstance(frame, nodes.Module):
12            self.add_message("global-at-module-level", node=node, confidence=HIGH)
13            return
14
15        module = frame.root()
16        default_message = True
17        locals_ = node.scope().locals
18        for name in node.names:
19            try:
20                assign_nodes = module.getattr(name)
21            except astroid.NotFoundError:
22                # unassigned global, skip
23                assign_nodes = []
24
25            not_defined_locally_by_import = not any(
26                isinstance(local, (nodes.Import, nodes.ImportFrom))
27                for local in locals_.get(name, ())
28            )
29            if (
30                not utils.is_reassigned_after_current(node, name)
31                and not utils.is_deleted_after_current(node, name)
32                and not_defined_locally_by_import
33            ):
34                self.add_message(
35                    "global-variable-not-assigned",
36                    args=name,
37                    node=node,
38                    confidence=HIGH,
39                )
40                default_message = False
41                continue
42
43            for anode in assign_nodes:
44                if (
45                    isinstance(anode, nodes.AssignName)
46                    and anode.name in module.special_attributes
47                ):
48                    self.add_message("redefined-builtin", args=name, node=node)
49                    break
50                if anode.frame(future=True) is module:
51                    # module level assignment
52                    break
53                if (
54                    isinstance(anode, (nodes.ClassDef, nodes.FunctionDef))
55                    and anode.parent is module
56                ):
57                    # module level function assignment
58                    break
59            else:
60                if not_defined_locally_by_import:
61                    # global undefined at the module scope
62                    self.add_message(
63                        "global-variable-undefined",
64                        args=name,
65                        node=node,
66                        confidence=HIGH,
67                    )
68                    default_message = False
69
70        if default_message:
71            self.add_message("global-statement", node=node, confidence=HIGH)

Path 8: 1 calls (0.03)

Global (1) 

1@utils.only_required_for_messages(
2        "global-variable-undefined",
3        "global-variable-not-assigned",
4        "global-statement",
5        "global-at-module-level",
6        "redefined-builtin",
7    )
8    def visit_global(self, node: nodes.Global) -> None:
9        """Check names imported exists in the global scope."""
10        frame = node.frame(future=True)
11        if isinstance(frame, nodes.Module):
12            self.add_message("global-at-module-level", node=node, confidence=HIGH)
13            return
14
15        module = frame.root()
16        default_message = True
17        locals_ = node.scope().locals
18        for name in node.names:
19            try:
20                assign_nodes = module.getattr(name)
21            except astroid.NotFoundError:
22                # unassigned global, skip
23                assign_nodes = []
24
25            not_defined_locally_by_import = not any(
26                isinstance(local, (nodes.Import, nodes.ImportFrom))
27                for local in locals_.get(name, ())
28            )
29            if (
30                not utils.is_reassigned_after_current(node, name)
31                and not utils.is_deleted_after_current(node, name)
32                and not_defined_locally_by_import
33            ):
34                self.add_message(
35                    "global-variable-not-assigned",
36                    args=name,
37                    node=node,
38                    confidence=HIGH,
39                )
40                default_message = False
41                continue
42
43            for anode in assign_nodes:
44                if (
45                    isinstance(anode, nodes.AssignName)
46                    and anode.name in module.special_attributes
47                ):
48                    self.add_message("redefined-builtin", args=name, node=node)
49                    break
50                if anode.frame(future=True) is module:
51                    # module level assignment
52                    break
53                if (
54                    isinstance(anode, (nodes.ClassDef, nodes.FunctionDef))
55                    and anode.parent is module
56                ):
57                    # module level function assignment
58                    break
59            else:
60                if not_defined_locally_by_import:
61                    # global undefined at the module scope
62                    self.add_message(
63                        "global-variable-undefined",
64                        args=name,
65                        node=node,
66                        confidence=HIGH,
67                    )
68                    default_message = False
69
70        if default_message:
71            self.add_message("global-statement", node=node, confidence=HIGH)

Path 9: 1 calls (0.03)

Global (1) 

1@utils.only_required_for_messages(
2        "global-variable-undefined",
3        "global-variable-not-assigned",
4        "global-statement",
5        "global-at-module-level",
6        "redefined-builtin",
7    )
8    def visit_global(self, node: nodes.Global) -> None:
9        """Check names imported exists in the global scope."""
10        frame = node.frame(future=True)
11        if isinstance(frame, nodes.Module):
12            self.add_message("global-at-module-level", node=node, confidence=HIGH)
13            return
14
15        module = frame.root()
16        default_message = True
17        locals_ = node.scope().locals
18        for name in node.names:
19            try:
20                assign_nodes = module.getattr(name)
21            except astroid.NotFoundError:
22                # unassigned global, skip
23                assign_nodes = []
24
25            not_defined_locally_by_import = not any(
26                isinstance(local, (nodes.Import, nodes.ImportFrom))
27                for local in locals_.get(name, ())
28            )
29            if (
30                not utils.is_reassigned_after_current(node, name)
31                and not utils.is_deleted_after_current(node, name)
32                and not_defined_locally_by_import
33            ):
34                self.add_message(
35                    "global-variable-not-assigned",
36                    args=name,
37                    node=node,
38                    confidence=HIGH,
39                )
40                default_message = False
41                continue
42
43            for anode in assign_nodes:
44                if (
45                    isinstance(anode, nodes.AssignName)
46                    and anode.name in module.special_attributes
47                ):
48                    self.add_message("redefined-builtin", args=name, node=node)
49                    break
50                if anode.frame(future=True) is module:
51                    # module level assignment
52                    break
53                if (
54                    isinstance(anode, (nodes.ClassDef, nodes.FunctionDef))
55                    and anode.parent is module
56                ):
57                    # module level function assignment
58                    break
59            else:
60                if not_defined_locally_by_import:
61                    # global undefined at the module scope
62                    self.add_message(
63                        "global-variable-undefined",
64                        args=name,
65                        node=node,
66                        confidence=HIGH,
67                    )
68                    default_message = False
69
70        if default_message:
71            self.add_message("global-statement", node=node, confidence=HIGH)

Path 10: 1 calls (0.03)

Global (1)

GeneratorExit (1) 

1@utils.only_required_for_messages(
2        "global-variable-undefined",
3        "global-variable-not-assigned",
4        "global-statement",
5        "global-at-module-level",
6        "redefined-builtin",
7    )
8    def visit_global(self, node: nodes.Global) -> None:
9        """Check names imported exists in the global scope."""
10        frame = node.frame(future=True)
11        if isinstance(frame, nodes.Module):
12            self.add_message("global-at-module-level", node=node, confidence=HIGH)
13            return
14
15        module = frame.root()
16        default_message = True
17        locals_ = node.scope().locals
18        for name in node.names:
19            try:
20                assign_nodes = module.getattr(name)
21            except astroid.NotFoundError:
22                # unassigned global, skip
23                assign_nodes = []
24
25            not_defined_locally_by_import = not any(
26                isinstance(local, (nodes.Import, nodes.ImportFrom))
27                for local in locals_.get(name, ())
28            )
29            if (
30                not utils.is_reassigned_after_current(node, name)
31                and not utils.is_deleted_after_current(node, name)
32                and not_defined_locally_by_import
33            ):
34                self.add_message(
35                    "global-variable-not-assigned",
36                    args=name,
37                    node=node,
38                    confidence=HIGH,
39                )
40                default_message = False
41                continue
42
43            for anode in assign_nodes:
44                if (
45                    isinstance(anode, nodes.AssignName)
46                    and anode.name in module.special_attributes
47                ):
48                    self.add_message("redefined-builtin", args=name, node=node)
49                    break
50                if anode.frame(future=True) is module:
51                    # module level assignment
52                    break
53                if (
54                    isinstance(anode, (nodes.ClassDef, nodes.FunctionDef))
55                    and anode.parent is module
56                ):
57                    # module level function assignment
58                    break
59            else:
60                if not_defined_locally_by_import:
61                    # global undefined at the module scope
62                    self.add_message(
63                        "global-variable-undefined",
64                        args=name,
65                        node=node,
66                        confidence=HIGH,
67                    )
68                    default_message = False
69
70        if default_message:
71            self.add_message("global-statement", node=node, confidence=HIGH)

Path 11: 1 calls (0.03)

Global (1)

GeneratorExit (1) 

1@utils.only_required_for_messages(
2        "global-variable-undefined",
3        "global-variable-not-assigned",
4        "global-statement",
5        "global-at-module-level",
6        "redefined-builtin",
7    )
8    def visit_global(self, node: nodes.Global) -> None:
9        """Check names imported exists in the global scope."""
10        frame = node.frame(future=True)
11        if isinstance(frame, nodes.Module):
12            self.add_message("global-at-module-level", node=node, confidence=HIGH)
13            return
14
15        module = frame.root()
16        default_message = True
17        locals_ = node.scope().locals
18        for name in node.names:
19            try:
20                assign_nodes = module.getattr(name)
21            except astroid.NotFoundError:
22                # unassigned global, skip
23                assign_nodes = []
24
25            not_defined_locally_by_import = not any(
26                isinstance(local, (nodes.Import, nodes.ImportFrom))
27                for local in locals_.get(name, ())
28            )
29            if (
30                not utils.is_reassigned_after_current(node, name)
31                and not utils.is_deleted_after_current(node, name)
32                and not_defined_locally_by_import
33            ):
34                self.add_message(
35                    "global-variable-not-assigned",
36                    args=name,
37                    node=node,
38                    confidence=HIGH,
39                )
40                default_message = False
41                continue
42
43            for anode in assign_nodes:
44                if (
45                    isinstance(anode, nodes.AssignName)
46                    and anode.name in module.special_attributes
47                ):
48                    self.add_message("redefined-builtin", args=name, node=node)
49                    break
50                if anode.frame(future=True) is module:
51                    # module level assignment
52                    break
53                if (
54                    isinstance(anode, (nodes.ClassDef, nodes.FunctionDef))
55                    and anode.parent is module
56                ):
57                    # module level function assignment
58                    break
59            else:
60                if not_defined_locally_by_import:
61                    # global undefined at the module scope
62                    self.add_message(
63                        "global-variable-undefined",
64                        args=name,
65                        node=node,
66                        confidence=HIGH,
67                    )
68                    default_message = False
69
70        if default_message:
71            self.add_message("global-statement", node=node, confidence=HIGH)