Path 1: 1411 calls (0.95)

→ klass ClassDef (1411)

→ parent_node Module (1361) FunctionDef (50)

↩ return [] (1411)

2 run 38 not run

1def _check_classdef_metaclasses(
2        self, klass: nodes.ClassDef, parent_node: nodes.Module | nodes.FunctionDef
3    ) -> list[tuple[dict[str, list[nodes.NodeNG]], str]]:
4        if not klass._metaclass:
5            # Skip if this class doesn't use explicitly a metaclass, but inherits it from ancestors
6            return []
7
8        consumed: list[tuple[dict[str, list[nodes.NodeNG]], str]] = []
9        metaclass = klass.metaclass()
10        name = ""
11        if isinstance(klass._metaclass, nodes.Name):
12            name = klass._metaclass.name
13        elif isinstance(klass._metaclass, nodes.Attribute) and klass._metaclass.expr:
14            attr = klass._metaclass.expr
15            while not isinstance(attr, nodes.Name):
16                attr = attr.expr
17            name = attr.name
18        elif isinstance(klass._metaclass, nodes.Call) and isinstance(
19            klass._metaclass.func, nodes.Name
20        ):
21            name = klass._metaclass.func.name
22        elif metaclass:
23            name = metaclass.root().name
24
25        found = False
26        name = METACLASS_NAME_TRANSFORMS.get(name, name)
27        if name:
28            # check enclosing scopes starting from most local
29            for scope_locals, _, _, _ in self._to_consume[::-1]:
30                found_nodes = scope_locals.get(name, [])
31                for found_node in found_nodes:
32                    if found_node.lineno <= klass.lineno:
33                        consumed.append((scope_locals, name))
34                        found = True
35                        break
36            # Check parent scope
37            nodes_in_parent_scope = parent_node.locals.get(name, [])
38            for found_node_parent in nodes_in_parent_scope:
39                if found_node_parent.lineno <= klass.lineno:
40                    found = True
41                    break
42        if (
43            not found
44            and not metaclass
45            and not (
46                name in nodes.Module.scope_attrs
47                or utils.is_builtin(name)
48                or name in self.linter.config.additional_builtins
49            )
50        ):
51            self.add_message("undefined-variable", node=klass, args=(name,))
52
53        return consumed
            

Path 2: 44 calls (0.03)

→ klass ClassDef (44)

→ parent_node Module (43) FunctionDef (1)

↩ return list (44)

24 run 16 not run

1def _check_classdef_metaclasses(
2        self, klass: nodes.ClassDef, parent_node: nodes.Module | nodes.FunctionDef
3    ) -> list[tuple[dict[str, list[nodes.NodeNG]], str]]:
4        if not klass._metaclass:
5            # Skip if this class doesn't use explicitly a metaclass, but inherits it from ancestors
6            return []
7
8        consumed: list[tuple[dict[str, list[nodes.NodeNG]], str]] = []
9        metaclass = klass.metaclass()
10        name = ""
11        if isinstance(klass._metaclass, nodes.Name):
12            name = klass._metaclass.name
13        elif isinstance(klass._metaclass, nodes.Attribute) and klass._metaclass.expr:
14            attr = klass._metaclass.expr
15            while not isinstance(attr, nodes.Name):
16                attr = attr.expr
17            name = attr.name
18        elif isinstance(klass._metaclass, nodes.Call) and isinstance(
19            klass._metaclass.func, nodes.Name
20        ):
21            name = klass._metaclass.func.name
22        elif metaclass:
23            name = metaclass.root().name
24
25        found = False
26        name = METACLASS_NAME_TRANSFORMS.get(name, name)
27        if name:
28            # check enclosing scopes starting from most local
29            for scope_locals, _, _, _ in self._to_consume[::-1]:
30                found_nodes = scope_locals.get(name, [])
31                for found_node in found_nodes:
32                    if found_node.lineno <= klass.lineno:
33                        consumed.append((scope_locals, name))
34                        found = True
35                        break
36            # Check parent scope
37            nodes_in_parent_scope = parent_node.locals.get(name, [])
38            for found_node_parent in nodes_in_parent_scope:
39                if found_node_parent.lineno <= klass.lineno:
40                    found = True
41                    break
42        if (
43            not found
44            and not metaclass
45            and not (
46                name in nodes.Module.scope_attrs
47                or utils.is_builtin(name)
48                or name in self.linter.config.additional_builtins
49            )
50        ):
51            self.add_message("undefined-variable", node=klass, args=(name,))
52
53        return consumed
            

Path 3: 14 calls (0.01)

→ klass ClassDef (14)

→ parent_node Module (14)

↩ return [] (14)

23 run 17 not run

1def _check_classdef_metaclasses(
2        self, klass: nodes.ClassDef, parent_node: nodes.Module | nodes.FunctionDef
3    ) -> list[tuple[dict[str, list[nodes.NodeNG]], str]]:
4        if not klass._metaclass:
5            # Skip if this class doesn't use explicitly a metaclass, but inherits it from ancestors
6            return []
7
8        consumed: list[tuple[dict[str, list[nodes.NodeNG]], str]] = []
9        metaclass = klass.metaclass()
10        name = ""
11        if isinstance(klass._metaclass, nodes.Name):
12            name = klass._metaclass.name
13        elif isinstance(klass._metaclass, nodes.Attribute) and klass._metaclass.expr:
14            attr = klass._metaclass.expr
15            while not isinstance(attr, nodes.Name):
16                attr = attr.expr
17            name = attr.name
18        elif isinstance(klass._metaclass, nodes.Call) and isinstance(
19            klass._metaclass.func, nodes.Name
20        ):
21            name = klass._metaclass.func.name
22        elif metaclass:
23            name = metaclass.root().name
24
25        found = False
26        name = METACLASS_NAME_TRANSFORMS.get(name, name)
27        if name:
28            # check enclosing scopes starting from most local
29            for scope_locals, _, _, _ in self._to_consume[::-1]:
30                found_nodes = scope_locals.get(name, [])
31                for found_node in found_nodes:
32                    if found_node.lineno <= klass.lineno:
33                        consumed.append((scope_locals, name))
34                        found = True
35                        break
36            # Check parent scope
37            nodes_in_parent_scope = parent_node.locals.get(name, [])
38            for found_node_parent in nodes_in_parent_scope:
39                if found_node_parent.lineno <= klass.lineno:
40                    found = True
41                    break
42        if (
43            not found
44            and not metaclass
45            and not (
46                name in nodes.Module.scope_attrs
47                or utils.is_builtin(name)
48                or name in self.linter.config.additional_builtins
49            )
50        ):
51            self.add_message("undefined-variable", node=klass, args=(name,))
52
53        return consumed
            

Path 4: 4 calls (0.0)

→ klass ClassDef (4)

→ parent_node FunctionDef (4)

↩ return list (4)

21 run 19 not run

1def _check_classdef_metaclasses(
2        self, klass: nodes.ClassDef, parent_node: nodes.Module | nodes.FunctionDef
3    ) -> list[tuple[dict[str, list[nodes.NodeNG]], str]]:
4        if not klass._metaclass:
5            # Skip if this class doesn't use explicitly a metaclass, but inherits it from ancestors
6            return []
7
8        consumed: list[tuple[dict[str, list[nodes.NodeNG]], str]] = []
9        metaclass = klass.metaclass()
10        name = ""
11        if isinstance(klass._metaclass, nodes.Name):
12            name = klass._metaclass.name
13        elif isinstance(klass._metaclass, nodes.Attribute) and klass._metaclass.expr:
14            attr = klass._metaclass.expr
15            while not isinstance(attr, nodes.Name):
16                attr = attr.expr
17            name = attr.name
18        elif isinstance(klass._metaclass, nodes.Call) and isinstance(
19            klass._metaclass.func, nodes.Name
20        ):
21            name = klass._metaclass.func.name
22        elif metaclass:
23            name = metaclass.root().name
24
25        found = False
26        name = METACLASS_NAME_TRANSFORMS.get(name, name)
27        if name:
28            # check enclosing scopes starting from most local
29            for scope_locals, _, _, _ in self._to_consume[::-1]:
30                found_nodes = scope_locals.get(name, [])
31                for found_node in found_nodes:
32                    if found_node.lineno <= klass.lineno:
33                        consumed.append((scope_locals, name))
34                        found = True
35                        break
36            # Check parent scope
37            nodes_in_parent_scope = parent_node.locals.get(name, [])
38            for found_node_parent in nodes_in_parent_scope:
39                if found_node_parent.lineno <= klass.lineno:
40                    found = True
41                    break
42        if (
43            not found
44            and not metaclass
45            and not (
46                name in nodes.Module.scope_attrs
47                or utils.is_builtin(name)
48                or name in self.linter.config.additional_builtins
49            )
50        ):
51            self.add_message("undefined-variable", node=klass, args=(name,))
52
53        return consumed
            

Path 5: 3 calls (0.0)

→ klass ClassDef (3)

→ parent_node Module (3)

↩ return list (3)

27 run 13 not run

1def _check_classdef_metaclasses(
2        self, klass: nodes.ClassDef, parent_node: nodes.Module | nodes.FunctionDef
3    ) -> list[tuple[dict[str, list[nodes.NodeNG]], str]]:
4        if not klass._metaclass:
5            # Skip if this class doesn't use explicitly a metaclass, but inherits it from ancestors
6            return []
7
8        consumed: list[tuple[dict[str, list[nodes.NodeNG]], str]] = []
9        metaclass = klass.metaclass()
10        name = ""
11        if isinstance(klass._metaclass, nodes.Name):
12            name = klass._metaclass.name
13        elif isinstance(klass._metaclass, nodes.Attribute) and klass._metaclass.expr:
14            attr = klass._metaclass.expr
15            while not isinstance(attr, nodes.Name):
16                attr = attr.expr
17            name = attr.name
18        elif isinstance(klass._metaclass, nodes.Call) and isinstance(
19            klass._metaclass.func, nodes.Name
20        ):
21            name = klass._metaclass.func.name
22        elif metaclass:
23            name = metaclass.root().name
24
25        found = False
26        name = METACLASS_NAME_TRANSFORMS.get(name, name)
27        if name:
28            # check enclosing scopes starting from most local
29            for scope_locals, _, _, _ in self._to_consume[::-1]:
30                found_nodes = scope_locals.get(name, [])
31                for found_node in found_nodes:
32                    if found_node.lineno <= klass.lineno:
33                        consumed.append((scope_locals, name))
34                        found = True
35                        break
36            # Check parent scope
37            nodes_in_parent_scope = parent_node.locals.get(name, [])
38            for found_node_parent in nodes_in_parent_scope:
39                if found_node_parent.lineno <= klass.lineno:
40                    found = True
41                    break
42        if (
43            not found
44            and not metaclass
45            and not (
46                name in nodes.Module.scope_attrs
47                or utils.is_builtin(name)
48                or name in self.linter.config.additional_builtins
49            )
50        ):
51            self.add_message("undefined-variable", node=klass, args=(name,))
52
53        return consumed
            

Path 6: 2 calls (0.0)

→ klass ClassDef (2)

→ parent_node FunctionDef (1) Module (1)

↩ return list (2)

27 run 13 not run

1def _check_classdef_metaclasses(
2        self, klass: nodes.ClassDef, parent_node: nodes.Module | nodes.FunctionDef
3    ) -> list[tuple[dict[str, list[nodes.NodeNG]], str]]:
4        if not klass._metaclass:
5            # Skip if this class doesn't use explicitly a metaclass, but inherits it from ancestors
6            return []
7
8        consumed: list[tuple[dict[str, list[nodes.NodeNG]], str]] = []
9        metaclass = klass.metaclass()
10        name = ""
11        if isinstance(klass._metaclass, nodes.Name):
12            name = klass._metaclass.name
13        elif isinstance(klass._metaclass, nodes.Attribute) and klass._metaclass.expr:
14            attr = klass._metaclass.expr
15            while not isinstance(attr, nodes.Name):
16                attr = attr.expr
17            name = attr.name
18        elif isinstance(klass._metaclass, nodes.Call) and isinstance(
19            klass._metaclass.func, nodes.Name
20        ):
21            name = klass._metaclass.func.name
22        elif metaclass:
23            name = metaclass.root().name
24
25        found = False
26        name = METACLASS_NAME_TRANSFORMS.get(name, name)
27        if name:
28            # check enclosing scopes starting from most local
29            for scope_locals, _, _, _ in self._to_consume[::-1]:
30                found_nodes = scope_locals.get(name, [])
31                for found_node in found_nodes:
32                    if found_node.lineno <= klass.lineno:
33                        consumed.append((scope_locals, name))
34                        found = True
35                        break
36            # Check parent scope
37            nodes_in_parent_scope = parent_node.locals.get(name, [])
38            for found_node_parent in nodes_in_parent_scope:
39                if found_node_parent.lineno <= klass.lineno:
40                    found = True
41                    break
42        if (
43            not found
44            and not metaclass
45            and not (
46                name in nodes.Module.scope_attrs
47                or utils.is_builtin(name)
48                or name in self.linter.config.additional_builtins
49            )
50        ):
51            self.add_message("undefined-variable", node=klass, args=(name,))
52
53        return consumed
            

Path 7: 2 calls (0.0)

→ klass ClassDef (2)

→ parent_node Module (2)

↩ return [] (2)

20 run 20 not run

1def _check_classdef_metaclasses(
2        self, klass: nodes.ClassDef, parent_node: nodes.Module | nodes.FunctionDef
3    ) -> list[tuple[dict[str, list[nodes.NodeNG]], str]]:
4        if not klass._metaclass:
5            # Skip if this class doesn't use explicitly a metaclass, but inherits it from ancestors
6            return []
7
8        consumed: list[tuple[dict[str, list[nodes.NodeNG]], str]] = []
9        metaclass = klass.metaclass()
10        name = ""
11        if isinstance(klass._metaclass, nodes.Name):
12            name = klass._metaclass.name
13        elif isinstance(klass._metaclass, nodes.Attribute) and klass._metaclass.expr:
14            attr = klass._metaclass.expr
15            while not isinstance(attr, nodes.Name):
16                attr = attr.expr
17            name = attr.name
18        elif isinstance(klass._metaclass, nodes.Call) and isinstance(
19            klass._metaclass.func, nodes.Name
20        ):
21            name = klass._metaclass.func.name
22        elif metaclass:
23            name = metaclass.root().name
24
25        found = False
26        name = METACLASS_NAME_TRANSFORMS.get(name, name)
27        if name:
28            # check enclosing scopes starting from most local
29            for scope_locals, _, _, _ in self._to_consume[::-1]:
30                found_nodes = scope_locals.get(name, [])
31                for found_node in found_nodes:
32                    if found_node.lineno <= klass.lineno:
33                        consumed.append((scope_locals, name))
34                        found = True
35                        break
36            # Check parent scope
37            nodes_in_parent_scope = parent_node.locals.get(name, [])
38            for found_node_parent in nodes_in_parent_scope:
39                if found_node_parent.lineno <= klass.lineno:
40                    found = True
41                    break
42        if (
43            not found
44            and not metaclass
45            and not (
46                name in nodes.Module.scope_attrs
47                or utils.is_builtin(name)
48                or name in self.linter.config.additional_builtins
49            )
50        ):
51            self.add_message("undefined-variable", node=klass, args=(name,))
52
53        return consumed
            

Path 8: 2 calls (0.0)

→ klass ClassDef (2)

→ parent_node Module (2)

↩ return [] (2)

18 run 22 not run

1def _check_classdef_metaclasses(
2        self, klass: nodes.ClassDef, parent_node: nodes.Module | nodes.FunctionDef
3    ) -> list[tuple[dict[str, list[nodes.NodeNG]], str]]:
4        if not klass._metaclass:
5            # Skip if this class doesn't use explicitly a metaclass, but inherits it from ancestors
6            return []
7
8        consumed: list[tuple[dict[str, list[nodes.NodeNG]], str]] = []
9        metaclass = klass.metaclass()
10        name = ""
11        if isinstance(klass._metaclass, nodes.Name):
12            name = klass._metaclass.name
13        elif isinstance(klass._metaclass, nodes.Attribute) and klass._metaclass.expr:
14            attr = klass._metaclass.expr
15            while not isinstance(attr, nodes.Name):
16                attr = attr.expr
17            name = attr.name
18        elif isinstance(klass._metaclass, nodes.Call) and isinstance(
19            klass._metaclass.func, nodes.Name
20        ):
21            name = klass._metaclass.func.name
22        elif metaclass:
23            name = metaclass.root().name
24
25        found = False
26        name = METACLASS_NAME_TRANSFORMS.get(name, name)
27        if name:
28            # check enclosing scopes starting from most local
29            for scope_locals, _, _, _ in self._to_consume[::-1]:
30                found_nodes = scope_locals.get(name, [])
31                for found_node in found_nodes:
32                    if found_node.lineno <= klass.lineno:
33                        consumed.append((scope_locals, name))
34                        found = True
35                        break
36            # Check parent scope
37            nodes_in_parent_scope = parent_node.locals.get(name, [])
38            for found_node_parent in nodes_in_parent_scope:
39                if found_node_parent.lineno <= klass.lineno:
40                    found = True
41                    break
42        if (
43            not found
44            and not metaclass
45            and not (
46                name in nodes.Module.scope_attrs
47                or utils.is_builtin(name)
48                or name in self.linter.config.additional_builtins
49            )
50        ):
51            self.add_message("undefined-variable", node=klass, args=(name,))
52
53        return consumed
            

Path 9: 2 calls (0.0)

→ klass ClassDef (2)

→ parent_node Module (2)

↩ return [] (2)

24 run 16 not run

1def _check_classdef_metaclasses(
2        self, klass: nodes.ClassDef, parent_node: nodes.Module | nodes.FunctionDef
3    ) -> list[tuple[dict[str, list[nodes.NodeNG]], str]]:
4        if not klass._metaclass:
5            # Skip if this class doesn't use explicitly a metaclass, but inherits it from ancestors
6            return []
7
8        consumed: list[tuple[dict[str, list[nodes.NodeNG]], str]] = []
9        metaclass = klass.metaclass()
10        name = ""
11        if isinstance(klass._metaclass, nodes.Name):
12            name = klass._metaclass.name
13        elif isinstance(klass._metaclass, nodes.Attribute) and klass._metaclass.expr:
14            attr = klass._metaclass.expr
15            while not isinstance(attr, nodes.Name):
16                attr = attr.expr
17            name = attr.name
18        elif isinstance(klass._metaclass, nodes.Call) and isinstance(
19            klass._metaclass.func, nodes.Name
20        ):
21            name = klass._metaclass.func.name
22        elif metaclass:
23            name = metaclass.root().name
24
25        found = False
26        name = METACLASS_NAME_TRANSFORMS.get(name, name)
27        if name:
28            # check enclosing scopes starting from most local
29            for scope_locals, _, _, _ in self._to_consume[::-1]:
30                found_nodes = scope_locals.get(name, [])
31                for found_node in found_nodes:
32                    if found_node.lineno <= klass.lineno:
33                        consumed.append((scope_locals, name))
34                        found = True
35                        break
36            # Check parent scope
37            nodes_in_parent_scope = parent_node.locals.get(name, [])
38            for found_node_parent in nodes_in_parent_scope:
39                if found_node_parent.lineno <= klass.lineno:
40                    found = True
41                    break
42        if (
43            not found
44            and not metaclass
45            and not (
46                name in nodes.Module.scope_attrs
47                or utils.is_builtin(name)
48                or name in self.linter.config.additional_builtins
49            )
50        ):
51            self.add_message("undefined-variable", node=klass, args=(name,))
52
53        return consumed
            

Path 10: 2 calls (0.0)

→ klass ClassDef (2)

→ parent_node Module (2)

↩ return [] (2)

25 run 15 not run

1def _check_classdef_metaclasses(
2        self, klass: nodes.ClassDef, parent_node: nodes.Module | nodes.FunctionDef
3    ) -> list[tuple[dict[str, list[nodes.NodeNG]], str]]:
4        if not klass._metaclass:
5            # Skip if this class doesn't use explicitly a metaclass, but inherits it from ancestors
6            return []
7
8        consumed: list[tuple[dict[str, list[nodes.NodeNG]], str]] = []
9        metaclass = klass.metaclass()
10        name = ""
11        if isinstance(klass._metaclass, nodes.Name):
12            name = klass._metaclass.name
13        elif isinstance(klass._metaclass, nodes.Attribute) and klass._metaclass.expr:
14            attr = klass._metaclass.expr
15            while not isinstance(attr, nodes.Name):
16                attr = attr.expr
17            name = attr.name
18        elif isinstance(klass._metaclass, nodes.Call) and isinstance(
19            klass._metaclass.func, nodes.Name
20        ):
21            name = klass._metaclass.func.name
22        elif metaclass:
23            name = metaclass.root().name
24
25        found = False
26        name = METACLASS_NAME_TRANSFORMS.get(name, name)
27        if name:
28            # check enclosing scopes starting from most local
29            for scope_locals, _, _, _ in self._to_consume[::-1]:
30                found_nodes = scope_locals.get(name, [])
31                for found_node in found_nodes:
32                    if found_node.lineno <= klass.lineno:
33                        consumed.append((scope_locals, name))
34                        found = True
35                        break
36            # Check parent scope
37            nodes_in_parent_scope = parent_node.locals.get(name, [])
38            for found_node_parent in nodes_in_parent_scope:
39                if found_node_parent.lineno <= klass.lineno:
40                    found = True
41                    break
42        if (
43            not found
44            and not metaclass
45            and not (
46                name in nodes.Module.scope_attrs
47                or utils.is_builtin(name)
48                or name in self.linter.config.additional_builtins
49            )
50        ):
51            self.add_message("undefined-variable", node=klass, args=(name,))
52
53        return consumed
            

Path 11: 1 calls (0.0)

→ klass ClassDef (1)

→ parent_node Module (1)

↩ return [] (1)

21 run 19 not run

1def _check_classdef_metaclasses(
2        self, klass: nodes.ClassDef, parent_node: nodes.Module | nodes.FunctionDef
3    ) -> list[tuple[dict[str, list[nodes.NodeNG]], str]]:
4        if not klass._metaclass:
5            # Skip if this class doesn't use explicitly a metaclass, but inherits it from ancestors
6            return []
7
8        consumed: list[tuple[dict[str, list[nodes.NodeNG]], str]] = []
9        metaclass = klass.metaclass()
10        name = ""
11        if isinstance(klass._metaclass, nodes.Name):
12            name = klass._metaclass.name
13        elif isinstance(klass._metaclass, nodes.Attribute) and klass._metaclass.expr:
14            attr = klass._metaclass.expr
15            while not isinstance(attr, nodes.Name):
16                attr = attr.expr
17            name = attr.name
18        elif isinstance(klass._metaclass, nodes.Call) and isinstance(
19            klass._metaclass.func, nodes.Name
20        ):
21            name = klass._metaclass.func.name
22        elif metaclass:
23            name = metaclass.root().name
24
25        found = False
26        name = METACLASS_NAME_TRANSFORMS.get(name, name)
27        if name:
28            # check enclosing scopes starting from most local
29            for scope_locals, _, _, _ in self._to_consume[::-1]:
30                found_nodes = scope_locals.get(name, [])
31                for found_node in found_nodes:
32                    if found_node.lineno <= klass.lineno:
33                        consumed.append((scope_locals, name))
34                        found = True
35                        break
36            # Check parent scope
37            nodes_in_parent_scope = parent_node.locals.get(name, [])
38            for found_node_parent in nodes_in_parent_scope:
39                if found_node_parent.lineno <= klass.lineno:
40                    found = True
41                    break
42        if (
43            not found
44            and not metaclass
45            and not (
46                name in nodes.Module.scope_attrs
47                or utils.is_builtin(name)
48                or name in self.linter.config.additional_builtins
49            )
50        ):
51            self.add_message("undefined-variable", node=klass, args=(name,))
52
53        return consumed
            

Path 12: 1 calls (0.0)

→ klass ClassDef (1)

→ parent_node Module (1)

↩ return list (1)

28 run 12 not run

1def _check_classdef_metaclasses(
2        self, klass: nodes.ClassDef, parent_node: nodes.Module | nodes.FunctionDef
3    ) -> list[tuple[dict[str, list[nodes.NodeNG]], str]]:
4        if not klass._metaclass:
5            # Skip if this class doesn't use explicitly a metaclass, but inherits it from ancestors
6            return []
7
8        consumed: list[tuple[dict[str, list[nodes.NodeNG]], str]] = []
9        metaclass = klass.metaclass()
10        name = ""
11        if isinstance(klass._metaclass, nodes.Name):
12            name = klass._metaclass.name
13        elif isinstance(klass._metaclass, nodes.Attribute) and klass._metaclass.expr:
14            attr = klass._metaclass.expr
15            while not isinstance(attr, nodes.Name):
16                attr = attr.expr
17            name = attr.name
18        elif isinstance(klass._metaclass, nodes.Call) and isinstance(
19            klass._metaclass.func, nodes.Name
20        ):
21            name = klass._metaclass.func.name
22        elif metaclass:
23            name = metaclass.root().name
24
25        found = False
26        name = METACLASS_NAME_TRANSFORMS.get(name, name)
27        if name:
28            # check enclosing scopes starting from most local
29            for scope_locals, _, _, _ in self._to_consume[::-1]:
30                found_nodes = scope_locals.get(name, [])
31                for found_node in found_nodes:
32                    if found_node.lineno <= klass.lineno:
33                        consumed.append((scope_locals, name))
34                        found = True
35                        break
36            # Check parent scope
37            nodes_in_parent_scope = parent_node.locals.get(name, [])
38            for found_node_parent in nodes_in_parent_scope:
39                if found_node_parent.lineno <= klass.lineno:
40                    found = True
41                    break
42        if (
43            not found
44            and not metaclass
45            and not (
46                name in nodes.Module.scope_attrs
47                or utils.is_builtin(name)
48                or name in self.linter.config.additional_builtins
49            )
50        ):
51            self.add_message("undefined-variable", node=klass, args=(name,))
52
53        return consumed
            

Path 13: 1 calls (0.0)

→ klass ClassDef (1)

→ parent_node Module (1)

↩ return [] (1)

22 run 18 not run

1def _check_classdef_metaclasses(
2        self, klass: nodes.ClassDef, parent_node: nodes.Module | nodes.FunctionDef
3    ) -> list[tuple[dict[str, list[nodes.NodeNG]], str]]:
4        if not klass._metaclass:
5            # Skip if this class doesn't use explicitly a metaclass, but inherits it from ancestors
6            return []
7
8        consumed: list[tuple[dict[str, list[nodes.NodeNG]], str]] = []
9        metaclass = klass.metaclass()
10        name = ""
11        if isinstance(klass._metaclass, nodes.Name):
12            name = klass._metaclass.name
13        elif isinstance(klass._metaclass, nodes.Attribute) and klass._metaclass.expr:
14            attr = klass._metaclass.expr
15            while not isinstance(attr, nodes.Name):
16                attr = attr.expr
17            name = attr.name
18        elif isinstance(klass._metaclass, nodes.Call) and isinstance(
19            klass._metaclass.func, nodes.Name
20        ):
21            name = klass._metaclass.func.name
22        elif metaclass:
23            name = metaclass.root().name
24
25        found = False
26        name = METACLASS_NAME_TRANSFORMS.get(name, name)
27        if name:
28            # check enclosing scopes starting from most local
29            for scope_locals, _, _, _ in self._to_consume[::-1]:
30                found_nodes = scope_locals.get(name, [])
31                for found_node in found_nodes:
32                    if found_node.lineno <= klass.lineno:
33                        consumed.append((scope_locals, name))
34                        found = True
35                        break
36            # Check parent scope
37            nodes_in_parent_scope = parent_node.locals.get(name, [])
38            for found_node_parent in nodes_in_parent_scope:
39                if found_node_parent.lineno <= klass.lineno:
40                    found = True
41                    break
42        if (
43            not found
44            and not metaclass
45            and not (
46                name in nodes.Module.scope_attrs
47                or utils.is_builtin(name)
48                or name in self.linter.config.additional_builtins
49            )
50        ):
51            self.add_message("undefined-variable", node=klass, args=(name,))
52
53        return consumed
            

Path 14: 1 calls (0.0)

→ klass ClassDef (1)

→ parent_node Module (1)

↩ return [] (1)

24 run 16 not run

1def _check_classdef_metaclasses(
2        self, klass: nodes.ClassDef, parent_node: nodes.Module | nodes.FunctionDef
3    ) -> list[tuple[dict[str, list[nodes.NodeNG]], str]]:
4        if not klass._metaclass:
5            # Skip if this class doesn't use explicitly a metaclass, but inherits it from ancestors
6            return []
7
8        consumed: list[tuple[dict[str, list[nodes.NodeNG]], str]] = []
9        metaclass = klass.metaclass()
10        name = ""
11        if isinstance(klass._metaclass, nodes.Name):
12            name = klass._metaclass.name
13        elif isinstance(klass._metaclass, nodes.Attribute) and klass._metaclass.expr:
14            attr = klass._metaclass.expr
15            while not isinstance(attr, nodes.Name):
16                attr = attr.expr
17            name = attr.name
18        elif isinstance(klass._metaclass, nodes.Call) and isinstance(
19            klass._metaclass.func, nodes.Name
20        ):
21            name = klass._metaclass.func.name
22        elif metaclass:
23            name = metaclass.root().name
24
25        found = False
26        name = METACLASS_NAME_TRANSFORMS.get(name, name)
27        if name:
28            # check enclosing scopes starting from most local
29            for scope_locals, _, _, _ in self._to_consume[::-1]:
30                found_nodes = scope_locals.get(name, [])
31                for found_node in found_nodes:
32                    if found_node.lineno <= klass.lineno:
33                        consumed.append((scope_locals, name))
34                        found = True
35                        break
36            # Check parent scope
37            nodes_in_parent_scope = parent_node.locals.get(name, [])
38            for found_node_parent in nodes_in_parent_scope:
39                if found_node_parent.lineno <= klass.lineno:
40                    found = True
41                    break
42        if (
43            not found
44            and not metaclass
45            and not (
46                name in nodes.Module.scope_attrs
47                or utils.is_builtin(name)
48                or name in self.linter.config.additional_builtins
49            )
50        ):
51            self.add_message("undefined-variable", node=klass, args=(name,))
52
53        return consumed