Path 1: 5635 calls (0.99)

Call (5635)

None (5635) 

1@only_required_for_messages("nested-min-max")
2    def visit_call(self, node: nodes.Call) -> None:
3        if not self.is_min_max_call(node):
4            return
5
6        redundant_calls = self.get_redundant_calls(node)
7        if not redundant_calls:
8            return
9
10        fixed_node = copy.copy(node)
11        while len(redundant_calls) > 0:
12            for i, arg in enumerate(fixed_node.args):
13                # Exclude any calls with generator expressions as there is no
14                # clear better suggestion for them.
15                if isinstance(arg, nodes.Call) and any(
16                    isinstance(a, nodes.GeneratorExp) for a in arg.args
17                ):
18                    return
19
20                if arg in redundant_calls:
21                    fixed_node.args = (
22                        fixed_node.args[:i] + arg.args + fixed_node.args[i + 1 :]
23                    )
24                    break
25
26            redundant_calls = self.get_redundant_calls(fixed_node)
27
28        self.add_message(
29            "nested-min-max",
30            node=node,
31            args=(node.func.name, fixed_node.as_string()),
32            confidence=INFERENCE,
33        )

Path 2: 21 calls (0.0)

Call (21)

None (21) 

1@only_required_for_messages("nested-min-max")
2    def visit_call(self, node: nodes.Call) -> None:
3        if not self.is_min_max_call(node):
4            return
5
6        redundant_calls = self.get_redundant_calls(node)
7        if not redundant_calls:
8            return
9
10        fixed_node = copy.copy(node)
11        while len(redundant_calls) > 0:
12            for i, arg in enumerate(fixed_node.args):
13                # Exclude any calls with generator expressions as there is no
14                # clear better suggestion for them.
15                if isinstance(arg, nodes.Call) and any(
16                    isinstance(a, nodes.GeneratorExp) for a in arg.args
17                ):
18                    return
19
20                if arg in redundant_calls:
21                    fixed_node.args = (
22                        fixed_node.args[:i] + arg.args + fixed_node.args[i + 1 :]
23                    )
24                    break
25
26            redundant_calls = self.get_redundant_calls(fixed_node)
27
28        self.add_message(
29            "nested-min-max",
30            node=node,
31            args=(node.func.name, fixed_node.as_string()),
32            confidence=INFERENCE,
33        )

Path 3: 8 calls (0.0)

Call (8) 

1@only_required_for_messages("nested-min-max")
2    def visit_call(self, node: nodes.Call) -> None:
3        if not self.is_min_max_call(node):
4            return
5
6        redundant_calls = self.get_redundant_calls(node)
7        if not redundant_calls:
8            return
9
10        fixed_node = copy.copy(node)
11        while len(redundant_calls) > 0:
12            for i, arg in enumerate(fixed_node.args):
13                # Exclude any calls with generator expressions as there is no
14                # clear better suggestion for them.
15                if isinstance(arg, nodes.Call) and any(
16                    isinstance(a, nodes.GeneratorExp) for a in arg.args
17                ):
18                    return
19
20                if arg in redundant_calls:
21                    fixed_node.args = (
22                        fixed_node.args[:i] + arg.args + fixed_node.args[i + 1 :]
23                    )
24                    break
25
26            redundant_calls = self.get_redundant_calls(fixed_node)
27
28        self.add_message(
29            "nested-min-max",
30            node=node,
31            args=(node.func.name, fixed_node.as_string()),
32            confidence=INFERENCE,
33        )

Path 4: 2 calls (0.0)

Call (2)

None (2)

GeneratorExit (2) 

1@only_required_for_messages("nested-min-max")
2    def visit_call(self, node: nodes.Call) -> None:
3        if not self.is_min_max_call(node):
4            return
5
6        redundant_calls = self.get_redundant_calls(node)
7        if not redundant_calls:
8            return
9
10        fixed_node = copy.copy(node)
11        while len(redundant_calls) > 0:
12            for i, arg in enumerate(fixed_node.args):
13                # Exclude any calls with generator expressions as there is no
14                # clear better suggestion for them.
15                if isinstance(arg, nodes.Call) and any(
16                    isinstance(a, nodes.GeneratorExp) for a in arg.args
17                ):
18                    return
19
20                if arg in redundant_calls:
21                    fixed_node.args = (
22                        fixed_node.args[:i] + arg.args + fixed_node.args[i + 1 :]
23                    )
24                    break
25
26            redundant_calls = self.get_redundant_calls(fixed_node)
27
28        self.add_message(
29            "nested-min-max",
30            node=node,
31            args=(node.func.name, fixed_node.as_string()),
32            confidence=INFERENCE,
33        )

Path 5: 1 calls (0.0)

Call (1)

None (1)

GeneratorExit (1) 

1@only_required_for_messages("nested-min-max")
2    def visit_call(self, node: nodes.Call) -> None:
3        if not self.is_min_max_call(node):
4            return
5
6        redundant_calls = self.get_redundant_calls(node)
7        if not redundant_calls:
8            return
9
10        fixed_node = copy.copy(node)
11        while len(redundant_calls) > 0:
12            for i, arg in enumerate(fixed_node.args):
13                # Exclude any calls with generator expressions as there is no
14                # clear better suggestion for them.
15                if isinstance(arg, nodes.Call) and any(
16                    isinstance(a, nodes.GeneratorExp) for a in arg.args
17                ):
18                    return
19
20                if arg in redundant_calls:
21                    fixed_node.args = (
22                        fixed_node.args[:i] + arg.args + fixed_node.args[i + 1 :]
23                    )
24                    break
25
26            redundant_calls = self.get_redundant_calls(fixed_node)
27
28        self.add_message(
29            "nested-min-max",
30            node=node,
31            args=(node.func.name, fixed_node.as_string()),
32            confidence=INFERENCE,
33        )