Path 1: 491 calls (0.96)

→ node AssignAttr (491)

↩ return None (491)

2 run 19 not run

1def _check_invalid_class_object(self, node: nodes.AssignAttr) -> None:
2        if not node.attrname == "__class__":
3            return
4        if isinstance(node.parent, nodes.Tuple):
5            class_index = -1
6            for i, elt in enumerate(node.parent.elts):
7                if hasattr(elt, "attrname") and elt.attrname == "__class__":
8                    class_index = i
9            if class_index == -1:
10                # This should not happen because we checked that the node name
11                # is '__class__' earlier, but let's not be too confident here
12                return  # pragma: no cover
13            inferred = safe_infer(node.parent.parent.value.elts[class_index])
14        else:
15            inferred = safe_infer(node.parent.value)
16        if (
17            isinstance(inferred, nodes.ClassDef)
18            or inferred is astroid.Uninferable
19            or inferred is None
20        ):
21            # If is uninferable, we allow it to prevent false positives
22            return
23        self.add_message(
24            "invalid-class-object",
25            node=node,
26            args=inferred.__class__.__name__,
27            confidence=INFERENCE,
28        )
            

Path 2: 9 calls (0.02)

→ node AssignAttr (9)

↩ return None (9)

6 run 15 not run

1def _check_invalid_class_object(self, node: nodes.AssignAttr) -> None:
2        if not node.attrname == "__class__":
3            return
4        if isinstance(node.parent, nodes.Tuple):
5            class_index = -1
6            for i, elt in enumerate(node.parent.elts):
7                if hasattr(elt, "attrname") and elt.attrname == "__class__":
8                    class_index = i
9            if class_index == -1:
10                # This should not happen because we checked that the node name
11                # is '__class__' earlier, but let's not be too confident here
12                return  # pragma: no cover
13            inferred = safe_infer(node.parent.parent.value.elts[class_index])
14        else:
15            inferred = safe_infer(node.parent.value)
16        if (
17            isinstance(inferred, nodes.ClassDef)
18            or inferred is astroid.Uninferable
19            or inferred is None
20        ):
21            # If is uninferable, we allow it to prevent false positives
22            return
23        self.add_message(
24            "invalid-class-object",
25            node=node,
26            args=inferred.__class__.__name__,
27            confidence=INFERENCE,
28        )
            

Path 3: 3 calls (0.01)

→ node AssignAttr (3)

↩ return None (3)

11 run 10 not run

1def _check_invalid_class_object(self, node: nodes.AssignAttr) -> None:
2        if not node.attrname == "__class__":
3            return
4        if isinstance(node.parent, nodes.Tuple):
5            class_index = -1
6            for i, elt in enumerate(node.parent.elts):
7                if hasattr(elt, "attrname") and elt.attrname == "__class__":
8                    class_index = i
9            if class_index == -1:
10                # This should not happen because we checked that the node name
11                # is '__class__' earlier, but let's not be too confident here
12                return  # pragma: no cover
13            inferred = safe_infer(node.parent.parent.value.elts[class_index])
14        else:
15            inferred = safe_infer(node.parent.value)
16        if (
17            isinstance(inferred, nodes.ClassDef)
18            or inferred is astroid.Uninferable
19            or inferred is None
20        ):
21            # If is uninferable, we allow it to prevent false positives
22            return
23        self.add_message(
24            "invalid-class-object",
25            node=node,
26            args=inferred.__class__.__name__,
27            confidence=INFERENCE,
28        )
            

Path 4: 3 calls (0.01)

→ node AssignAttr (3)

17 run 4 not run

1def _check_invalid_class_object(self, node: nodes.AssignAttr) -> None:
2        if not node.attrname == "__class__":
3            return
4        if isinstance(node.parent, nodes.Tuple):
5            class_index = -1
6            for i, elt in enumerate(node.parent.elts):
7                if hasattr(elt, "attrname") and elt.attrname == "__class__":
8                    class_index = i
9            if class_index == -1:
10                # This should not happen because we checked that the node name
11                # is '__class__' earlier, but let's not be too confident here
12                return  # pragma: no cover
13            inferred = safe_infer(node.parent.parent.value.elts[class_index])
14        else:
15            inferred = safe_infer(node.parent.value)
16        if (
17            isinstance(inferred, nodes.ClassDef)
18            or inferred is astroid.Uninferable
19            or inferred is None
20        ):
21            # If is uninferable, we allow it to prevent false positives
22            return
23        self.add_message(
24            "invalid-class-object",
25            node=node,
26            args=inferred.__class__.__name__,
27            confidence=INFERENCE,
28        )
            

Path 5: 2 calls (0.0)

→ node AssignAttr (2)

12 run 9 not run

1def _check_invalid_class_object(self, node: nodes.AssignAttr) -> None:
2        if not node.attrname == "__class__":
3            return
4        if isinstance(node.parent, nodes.Tuple):
5            class_index = -1
6            for i, elt in enumerate(node.parent.elts):
7                if hasattr(elt, "attrname") and elt.attrname == "__class__":
8                    class_index = i
9            if class_index == -1:
10                # This should not happen because we checked that the node name
11                # is '__class__' earlier, but let's not be too confident here
12                return  # pragma: no cover
13            inferred = safe_infer(node.parent.parent.value.elts[class_index])
14        else:
15            inferred = safe_infer(node.parent.value)
16        if (
17            isinstance(inferred, nodes.ClassDef)
18            or inferred is astroid.Uninferable
19            or inferred is None
20        ):
21            # If is uninferable, we allow it to prevent false positives
22            return
23        self.add_message(
24            "invalid-class-object",
25            node=node,
26            args=inferred.__class__.__name__,
27            confidence=INFERENCE,
28        )
            

Path 6: 1 calls (0.0)

→ node AssignAttr (1)

↩ return None (1)

7 run 14 not run

1def _check_invalid_class_object(self, node: nodes.AssignAttr) -> None:
2        if not node.attrname == "__class__":
3            return
4        if isinstance(node.parent, nodes.Tuple):
5            class_index = -1
6            for i, elt in enumerate(node.parent.elts):
7                if hasattr(elt, "attrname") and elt.attrname == "__class__":
8                    class_index = i
9            if class_index == -1:
10                # This should not happen because we checked that the node name
11                # is '__class__' earlier, but let's not be too confident here
12                return  # pragma: no cover
13            inferred = safe_infer(node.parent.parent.value.elts[class_index])
14        else:
15            inferred = safe_infer(node.parent.value)
16        if (
17            isinstance(inferred, nodes.ClassDef)
18            or inferred is astroid.Uninferable
19            or inferred is None
20        ):
21            # If is uninferable, we allow it to prevent false positives
22            return
23        self.add_message(
24            "invalid-class-object",
25            node=node,
26            args=inferred.__class__.__name__,
27            confidence=INFERENCE,
28        )
            

Path 7: 1 calls (0.0)

→ node AssignAttr (1)

↩ return None (1)

8 run 13 not run

1def _check_invalid_class_object(self, node: nodes.AssignAttr) -> None:
2        if not node.attrname == "__class__":
3            return
4        if isinstance(node.parent, nodes.Tuple):
5            class_index = -1
6            for i, elt in enumerate(node.parent.elts):
7                if hasattr(elt, "attrname") and elt.attrname == "__class__":
8                    class_index = i
9            if class_index == -1:
10                # This should not happen because we checked that the node name
11                # is '__class__' earlier, but let's not be too confident here
12                return  # pragma: no cover
13            inferred = safe_infer(node.parent.parent.value.elts[class_index])
14        else:
15            inferred = safe_infer(node.parent.value)
16        if (
17            isinstance(inferred, nodes.ClassDef)
18            or inferred is astroid.Uninferable
19            or inferred is None
20        ):
21            # If is uninferable, we allow it to prevent false positives
22            return
23        self.add_message(
24            "invalid-class-object",
25            node=node,
26            args=inferred.__class__.__name__,
27            confidence=INFERENCE,
28        )