Path 1: 110 calls (0.5)

→ node UnaryOp (110)

↩ return None (110)

2 run 29 not run

1@utils.only_required_for_messages("unneeded-not")
2    def visit_unaryop(self, node: nodes.UnaryOp) -> None:
3        if node.op != "not":
4            return
5        operand = node.operand
6
7        if isinstance(operand, nodes.UnaryOp) and operand.op == "not":
8            self.add_message(
9                "unneeded-not",
10                node=node,
11                args=(node.as_string(), operand.operand.as_string()),
12            )
13        elif isinstance(operand, nodes.Compare):
14            left = operand.left
15            # ignore multiple comparisons
16            if len(operand.ops) > 1:
17                return
18            operator, right = operand.ops[0]
19            if operator not in self.reverse_op:
20                return
21            # Ignore __ne__ as function of __eq__
22            frame = node.frame(future=True)
23            if frame.name == "__ne__" and operator == "==":
24                return
25            for _type in (utils.node_type(left), utils.node_type(right)):
26                if not _type:
27                    return
28                if isinstance(_type, self.skipped_nodes):
29                    return
30                if (
31                    isinstance(_type, astroid.Instance)
32                    and _type.qname() in self.skipped_classnames
33                ):
34                    return
35            suggestion = (
36                f"{left.as_string()} {self.reverse_op[operator]} {right.as_string()}"
37            )
38            self.add_message(
39                "unneeded-not", node=node, args=(node.as_string(), suggestion)
40            )
            

Path 2: 83 calls (0.38)

→ node UnaryOp (83)

4 run 27 not run

1@utils.only_required_for_messages("unneeded-not")
2    def visit_unaryop(self, node: nodes.UnaryOp) -> None:
3        if node.op != "not":
4            return
5        operand = node.operand
6
7        if isinstance(operand, nodes.UnaryOp) and operand.op == "not":
8            self.add_message(
9                "unneeded-not",
10                node=node,
11                args=(node.as_string(), operand.operand.as_string()),
12            )
13        elif isinstance(operand, nodes.Compare):
14            left = operand.left
15            # ignore multiple comparisons
16            if len(operand.ops) > 1:
17                return
18            operator, right = operand.ops[0]
19            if operator not in self.reverse_op:
20                return
21            # Ignore __ne__ as function of __eq__
22            frame = node.frame(future=True)
23            if frame.name == "__ne__" and operator == "==":
24                return
25            for _type in (utils.node_type(left), utils.node_type(right)):
26                if not _type:
27                    return
28                if isinstance(_type, self.skipped_nodes):
29                    return
30                if (
31                    isinstance(_type, astroid.Instance)
32                    and _type.qname() in self.skipped_classnames
33                ):
34                    return
35            suggestion = (
36                f"{left.as_string()} {self.reverse_op[operator]} {right.as_string()}"
37            )
38            self.add_message(
39                "unneeded-not", node=node, args=(node.as_string(), suggestion)
40            )
            

Path 3: 15 calls (0.07)

→ node UnaryOp (15)

20 run 11 not run

1@utils.only_required_for_messages("unneeded-not")
2    def visit_unaryop(self, node: nodes.UnaryOp) -> None:
3        if node.op != "not":
4            return
5        operand = node.operand
6
7        if isinstance(operand, nodes.UnaryOp) and operand.op == "not":
8            self.add_message(
9                "unneeded-not",
10                node=node,
11                args=(node.as_string(), operand.operand.as_string()),
12            )
13        elif isinstance(operand, nodes.Compare):
14            left = operand.left
15            # ignore multiple comparisons
16            if len(operand.ops) > 1:
17                return
18            operator, right = operand.ops[0]
19            if operator not in self.reverse_op:
20                return
21            # Ignore __ne__ as function of __eq__
22            frame = node.frame(future=True)
23            if frame.name == "__ne__" and operator == "==":
24                return
25            for _type in (utils.node_type(left), utils.node_type(right)):
26                if not _type:
27                    return
28                if isinstance(_type, self.skipped_nodes):
29                    return
30                if (
31                    isinstance(_type, astroid.Instance)
32                    and _type.qname() in self.skipped_classnames
33                ):
34                    return
35            suggestion = (
36                f"{left.as_string()} {self.reverse_op[operator]} {right.as_string()}"
37            )
38            self.add_message(
39                "unneeded-not", node=node, args=(node.as_string(), suggestion)
40            )
            

Path 4: 2 calls (0.01)

→ node UnaryOp (2)

↩ return None (2)

13 run 18 not run

1@utils.only_required_for_messages("unneeded-not")
2    def visit_unaryop(self, node: nodes.UnaryOp) -> None:
3        if node.op != "not":
4            return
5        operand = node.operand
6
7        if isinstance(operand, nodes.UnaryOp) and operand.op == "not":
8            self.add_message(
9                "unneeded-not",
10                node=node,
11                args=(node.as_string(), operand.operand.as_string()),
12            )
13        elif isinstance(operand, nodes.Compare):
14            left = operand.left
15            # ignore multiple comparisons
16            if len(operand.ops) > 1:
17                return
18            operator, right = operand.ops[0]
19            if operator not in self.reverse_op:
20                return
21            # Ignore __ne__ as function of __eq__
22            frame = node.frame(future=True)
23            if frame.name == "__ne__" and operator == "==":
24                return
25            for _type in (utils.node_type(left), utils.node_type(right)):
26                if not _type:
27                    return
28                if isinstance(_type, self.skipped_nodes):
29                    return
30                if (
31                    isinstance(_type, astroid.Instance)
32                    and _type.qname() in self.skipped_classnames
33                ):
34                    return
35            suggestion = (
36                f"{left.as_string()} {self.reverse_op[operator]} {right.as_string()}"
37            )
38            self.add_message(
39                "unneeded-not", node=node, args=(node.as_string(), suggestion)
40            )
            

Path 5: 2 calls (0.01)

→ node UnaryOp (2)

7 run 24 not run

1@utils.only_required_for_messages("unneeded-not")
2    def visit_unaryop(self, node: nodes.UnaryOp) -> None:
3        if node.op != "not":
4            return
5        operand = node.operand
6
7        if isinstance(operand, nodes.UnaryOp) and operand.op == "not":
8            self.add_message(
9                "unneeded-not",
10                node=node,
11                args=(node.as_string(), operand.operand.as_string()),
12            )
13        elif isinstance(operand, nodes.Compare):
14            left = operand.left
15            # ignore multiple comparisons
16            if len(operand.ops) > 1:
17                return
18            operator, right = operand.ops[0]
19            if operator not in self.reverse_op:
20                return
21            # Ignore __ne__ as function of __eq__
22            frame = node.frame(future=True)
23            if frame.name == "__ne__" and operator == "==":
24                return
25            for _type in (utils.node_type(left), utils.node_type(right)):
26                if not _type:
27                    return
28                if isinstance(_type, self.skipped_nodes):
29                    return
30                if (
31                    isinstance(_type, astroid.Instance)
32                    and _type.qname() in self.skipped_classnames
33                ):
34                    return
35            suggestion = (
36                f"{left.as_string()} {self.reverse_op[operator]} {right.as_string()}"
37            )
38            self.add_message(
39                "unneeded-not", node=node, args=(node.as_string(), suggestion)
40            )
            

Path 6: 2 calls (0.01)

→ node UnaryOp (2)

↩ return None (2)

7 run 24 not run

1@utils.only_required_for_messages("unneeded-not")
2    def visit_unaryop(self, node: nodes.UnaryOp) -> None:
3        if node.op != "not":
4            return
5        operand = node.operand
6
7        if isinstance(operand, nodes.UnaryOp) and operand.op == "not":
8            self.add_message(
9                "unneeded-not",
10                node=node,
11                args=(node.as_string(), operand.operand.as_string()),
12            )
13        elif isinstance(operand, nodes.Compare):
14            left = operand.left
15            # ignore multiple comparisons
16            if len(operand.ops) > 1:
17                return
18            operator, right = operand.ops[0]
19            if operator not in self.reverse_op:
20                return
21            # Ignore __ne__ as function of __eq__
22            frame = node.frame(future=True)
23            if frame.name == "__ne__" and operator == "==":
24                return
25            for _type in (utils.node_type(left), utils.node_type(right)):
26                if not _type:
27                    return
28                if isinstance(_type, self.skipped_nodes):
29                    return
30                if (
31                    isinstance(_type, astroid.Instance)
32                    and _type.qname() in self.skipped_classnames
33                ):
34                    return
35            suggestion = (
36                f"{left.as_string()} {self.reverse_op[operator]} {right.as_string()}"
37            )
38            self.add_message(
39                "unneeded-not", node=node, args=(node.as_string(), suggestion)
40            )
            

Path 7: 2 calls (0.01)

→ node UnaryOp (2)

↩ return None (2)

17 run 14 not run

1@utils.only_required_for_messages("unneeded-not")
2    def visit_unaryop(self, node: nodes.UnaryOp) -> None:
3        if node.op != "not":
4            return
5        operand = node.operand
6
7        if isinstance(operand, nodes.UnaryOp) and operand.op == "not":
8            self.add_message(
9                "unneeded-not",
10                node=node,
11                args=(node.as_string(), operand.operand.as_string()),
12            )
13        elif isinstance(operand, nodes.Compare):
14            left = operand.left
15            # ignore multiple comparisons
16            if len(operand.ops) > 1:
17                return
18            operator, right = operand.ops[0]
19            if operator not in self.reverse_op:
20                return
21            # Ignore __ne__ as function of __eq__
22            frame = node.frame(future=True)
23            if frame.name == "__ne__" and operator == "==":
24                return
25            for _type in (utils.node_type(left), utils.node_type(right)):
26                if not _type:
27                    return
28                if isinstance(_type, self.skipped_nodes):
29                    return
30                if (
31                    isinstance(_type, astroid.Instance)
32                    and _type.qname() in self.skipped_classnames
33                ):
34                    return
35            suggestion = (
36                f"{left.as_string()} {self.reverse_op[operator]} {right.as_string()}"
37            )
38            self.add_message(
39                "unneeded-not", node=node, args=(node.as_string(), suggestion)
40            )
            

Path 8: 1 calls (0.0)

→ node UnaryOp (1)

↩ return None (1)

14 run 17 not run

1@utils.only_required_for_messages("unneeded-not")
2    def visit_unaryop(self, node: nodes.UnaryOp) -> None:
3        if node.op != "not":
4            return
5        operand = node.operand
6
7        if isinstance(operand, nodes.UnaryOp) and operand.op == "not":
8            self.add_message(
9                "unneeded-not",
10                node=node,
11                args=(node.as_string(), operand.operand.as_string()),
12            )
13        elif isinstance(operand, nodes.Compare):
14            left = operand.left
15            # ignore multiple comparisons
16            if len(operand.ops) > 1:
17                return
18            operator, right = operand.ops[0]
19            if operator not in self.reverse_op:
20                return
21            # Ignore __ne__ as function of __eq__
22            frame = node.frame(future=True)
23            if frame.name == "__ne__" and operator == "==":
24                return
25            for _type in (utils.node_type(left), utils.node_type(right)):
26                if not _type:
27                    return
28                if isinstance(_type, self.skipped_nodes):
29                    return
30                if (
31                    isinstance(_type, astroid.Instance)
32                    and _type.qname() in self.skipped_classnames
33                ):
34                    return
35            suggestion = (
36                f"{left.as_string()} {self.reverse_op[operator]} {right.as_string()}"
37            )
38            self.add_message(
39                "unneeded-not", node=node, args=(node.as_string(), suggestion)
40            )
            

Path 9: 1 calls (0.0)

→ node UnaryOp (1)

↩ return None (1)

11 run 20 not run

1@utils.only_required_for_messages("unneeded-not")
2    def visit_unaryop(self, node: nodes.UnaryOp) -> None:
3        if node.op != "not":
4            return
5        operand = node.operand
6
7        if isinstance(operand, nodes.UnaryOp) and operand.op == "not":
8            self.add_message(
9                "unneeded-not",
10                node=node,
11                args=(node.as_string(), operand.operand.as_string()),
12            )
13        elif isinstance(operand, nodes.Compare):
14            left = operand.left
15            # ignore multiple comparisons
16            if len(operand.ops) > 1:
17                return
18            operator, right = operand.ops[0]
19            if operator not in self.reverse_op:
20                return
21            # Ignore __ne__ as function of __eq__
22            frame = node.frame(future=True)
23            if frame.name == "__ne__" and operator == "==":
24                return
25            for _type in (utils.node_type(left), utils.node_type(right)):
26                if not _type:
27                    return
28                if isinstance(_type, self.skipped_nodes):
29                    return
30                if (
31                    isinstance(_type, astroid.Instance)
32                    and _type.qname() in self.skipped_classnames
33                ):
34                    return
35            suggestion = (
36                f"{left.as_string()} {self.reverse_op[operator]} {right.as_string()}"
37            )
38            self.add_message(
39                "unneeded-not", node=node, args=(node.as_string(), suggestion)
40            )