Path 1: 430 calls (0.82)

→ node For (430)

↩ return None (430)

2 run 15 not run

1@utils.only_required_for_messages(
2        "unbalanced-dict-unpacking",
3    )
4    def visit_for(self, node: nodes.For) -> None:
5        if not isinstance(node.target, nodes.Tuple):
6            return
7
8        targets = node.target.elts
9
10        inferred = utils.safe_infer(node.iter)
11        if not isinstance(inferred, DICT_TYPES):
12            return
13
14        values = self._nodes_to_unpack(inferred)
15        if not values:
16            # no dict items returned
17            return
18
19        if isinstance(inferred, astroid.objects.DictItems):
20            # dict.items() is a bit special because values will be a tuple
21            # So as long as there are always 2 targets and values each are
22            # a tuple with two items, this will unpack correctly.
23            # Example: `for key, val in {1: 2, 3: 4}.items()`
24            if len(targets) == 2 and all(len(x.elts) == 2 for x in values):
25                return
26
27            # Starred nodes indicate ambiguous unpacking
28            # if `dict.items()` is used so we won't flag them.
29            if any(isinstance(target, nodes.Starred) for target in targets):
30                return
31
32        if len(targets) != len(values):
33            details = _get_unpacking_extra_info(node, inferred)
34            self._report_unbalanced_unpacking(node, inferred, targets, values, details)
            

Path 2: 61 calls (0.12)

→ node For (61)

↩ return None (61)

5 run 12 not run

1@utils.only_required_for_messages(
2        "unbalanced-dict-unpacking",
3    )
4    def visit_for(self, node: nodes.For) -> None:
5        if not isinstance(node.target, nodes.Tuple):
6            return
7
8        targets = node.target.elts
9
10        inferred = utils.safe_infer(node.iter)
11        if not isinstance(inferred, DICT_TYPES):
12            return
13
14        values = self._nodes_to_unpack(inferred)
15        if not values:
16            # no dict items returned
17            return
18
19        if isinstance(inferred, astroid.objects.DictItems):
20            # dict.items() is a bit special because values will be a tuple
21            # So as long as there are always 2 targets and values each are
22            # a tuple with two items, this will unpack correctly.
23            # Example: `for key, val in {1: 2, 3: 4}.items()`
24            if len(targets) == 2 and all(len(x.elts) == 2 for x in values):
25                return
26
27            # Starred nodes indicate ambiguous unpacking
28            # if `dict.items()` is used so we won't flag them.
29            if any(isinstance(target, nodes.Starred) for target in targets):
30                return
31
32        if len(targets) != len(values):
33            details = _get_unpacking_extra_info(node, inferred)
34            self._report_unbalanced_unpacking(node, inferred, targets, values, details)
            

Path 3: 15 calls (0.03)

→ node For (15)

↩ return None (15)

9 run 8 not run

1@utils.only_required_for_messages(
2        "unbalanced-dict-unpacking",
3    )
4    def visit_for(self, node: nodes.For) -> None:
5        if not isinstance(node.target, nodes.Tuple):
6            return
7
8        targets = node.target.elts
9
10        inferred = utils.safe_infer(node.iter)
11        if not isinstance(inferred, DICT_TYPES):
12            return
13
14        values = self._nodes_to_unpack(inferred)
15        if not values:
16            # no dict items returned
17            return
18
19        if isinstance(inferred, astroid.objects.DictItems):
20            # dict.items() is a bit special because values will be a tuple
21            # So as long as there are always 2 targets and values each are
22            # a tuple with two items, this will unpack correctly.
23            # Example: `for key, val in {1: 2, 3: 4}.items()`
24            if len(targets) == 2 and all(len(x.elts) == 2 for x in values):
25                return
26
27            # Starred nodes indicate ambiguous unpacking
28            # if `dict.items()` is used so we won't flag them.
29            if any(isinstance(target, nodes.Starred) for target in targets):
30                return
31
32        if len(targets) != len(values):
33            details = _get_unpacking_extra_info(node, inferred)
34            self._report_unbalanced_unpacking(node, inferred, targets, values, details)
            

Path 4: 8 calls (0.02)

→ node For (8)

↩ return None (8)

7 run 10 not run

1@utils.only_required_for_messages(
2        "unbalanced-dict-unpacking",
3    )
4    def visit_for(self, node: nodes.For) -> None:
5        if not isinstance(node.target, nodes.Tuple):
6            return
7
8        targets = node.target.elts
9
10        inferred = utils.safe_infer(node.iter)
11        if not isinstance(inferred, DICT_TYPES):
12            return
13
14        values = self._nodes_to_unpack(inferred)
15        if not values:
16            # no dict items returned
17            return
18
19        if isinstance(inferred, astroid.objects.DictItems):
20            # dict.items() is a bit special because values will be a tuple
21            # So as long as there are always 2 targets and values each are
22            # a tuple with two items, this will unpack correctly.
23            # Example: `for key, val in {1: 2, 3: 4}.items()`
24            if len(targets) == 2 and all(len(x.elts) == 2 for x in values):
25                return
26
27            # Starred nodes indicate ambiguous unpacking
28            # if `dict.items()` is used so we won't flag them.
29            if any(isinstance(target, nodes.Starred) for target in targets):
30                return
31
32        if len(targets) != len(values):
33            details = _get_unpacking_extra_info(node, inferred)
34            self._report_unbalanced_unpacking(node, inferred, targets, values, details)
            

Path 5: 6 calls (0.01)

→ node For (6)

10 run 7 not run

1@utils.only_required_for_messages(
2        "unbalanced-dict-unpacking",
3    )
4    def visit_for(self, node: nodes.For) -> None:
5        if not isinstance(node.target, nodes.Tuple):
6            return
7
8        targets = node.target.elts
9
10        inferred = utils.safe_infer(node.iter)
11        if not isinstance(inferred, DICT_TYPES):
12            return
13
14        values = self._nodes_to_unpack(inferred)
15        if not values:
16            # no dict items returned
17            return
18
19        if isinstance(inferred, astroid.objects.DictItems):
20            # dict.items() is a bit special because values will be a tuple
21            # So as long as there are always 2 targets and values each are
22            # a tuple with two items, this will unpack correctly.
23            # Example: `for key, val in {1: 2, 3: 4}.items()`
24            if len(targets) == 2 and all(len(x.elts) == 2 for x in values):
25                return
26
27            # Starred nodes indicate ambiguous unpacking
28            # if `dict.items()` is used so we won't flag them.
29            if any(isinstance(target, nodes.Starred) for target in targets):
30                return
31
32        if len(targets) != len(values):
33            details = _get_unpacking_extra_info(node, inferred)
34            self._report_unbalanced_unpacking(node, inferred, targets, values, details)
            

Path 6: 2 calls (0.0)

→ node For (2)

8 run 9 not run

1@utils.only_required_for_messages(
2        "unbalanced-dict-unpacking",
3    )
4    def visit_for(self, node: nodes.For) -> None:
5        if not isinstance(node.target, nodes.Tuple):
6            return
7
8        targets = node.target.elts
9
10        inferred = utils.safe_infer(node.iter)
11        if not isinstance(inferred, DICT_TYPES):
12            return
13
14        values = self._nodes_to_unpack(inferred)
15        if not values:
16            # no dict items returned
17            return
18
19        if isinstance(inferred, astroid.objects.DictItems):
20            # dict.items() is a bit special because values will be a tuple
21            # So as long as there are always 2 targets and values each are
22            # a tuple with two items, this will unpack correctly.
23            # Example: `for key, val in {1: 2, 3: 4}.items()`
24            if len(targets) == 2 and all(len(x.elts) == 2 for x in values):
25                return
26
27            # Starred nodes indicate ambiguous unpacking
28            # if `dict.items()` is used so we won't flag them.
29            if any(isinstance(target, nodes.Starred) for target in targets):
30                return
31
32        if len(targets) != len(values):
33            details = _get_unpacking_extra_info(node, inferred)
34            self._report_unbalanced_unpacking(node, inferred, targets, values, details)
            

Path 7: 1 calls (0.0)

→ node For (1)

12 run 5 not run

1@utils.only_required_for_messages(
2        "unbalanced-dict-unpacking",
3    )
4    def visit_for(self, node: nodes.For) -> None:
5        if not isinstance(node.target, nodes.Tuple):
6            return
7
8        targets = node.target.elts
9
10        inferred = utils.safe_infer(node.iter)
11        if not isinstance(inferred, DICT_TYPES):
12            return
13
14        values = self._nodes_to_unpack(inferred)
15        if not values:
16            # no dict items returned
17            return
18
19        if isinstance(inferred, astroid.objects.DictItems):
20            # dict.items() is a bit special because values will be a tuple
21            # So as long as there are always 2 targets and values each are
22            # a tuple with two items, this will unpack correctly.
23            # Example: `for key, val in {1: 2, 3: 4}.items()`
24            if len(targets) == 2 and all(len(x.elts) == 2 for x in values):
25                return
26
27            # Starred nodes indicate ambiguous unpacking
28            # if `dict.items()` is used so we won't flag them.
29            if any(isinstance(target, nodes.Starred) for target in targets):
30                return
31
32        if len(targets) != len(values):
33            details = _get_unpacking_extra_info(node, inferred)
34            self._report_unbalanced_unpacking(node, inferred, targets, values, details)