Path 1: 11594 calls (0.48)

→ node Name (11504) AssignName (78) DelName (12)

→ consumer NamesConsumer (11594)

→ is_start_index True (5832) False (5762)

↩ return False (11594)

4 run 10 not run

1def _should_node_be_skipped(
2        self, node: nodes.Name, consumer: NamesConsumer, is_start_index: bool
3    ) -> bool:
4        """Tests a consumer and node for various conditions in which the node shouldn't
5        be checked for the undefined-variable and used-before-assignment checks.
6        """
7        if consumer.scope_type == "class":
8            # The list of base classes in the class definition is not part
9            # of the class body.
10            # If the current scope is a class scope but it's not the inner
11            # scope, ignore it. This prevents to access this scope instead of
12            # the globals one in function members when there are some common
13            # names.
14            if utils.is_ancestor_name(consumer.node, node) or (
15                not is_start_index and self._ignore_class_scope(node)
16            ):
17                return True
18
19            # Ignore inner class scope for keywords in class definition
20            if isinstance(node.parent, nodes.Keyword) and isinstance(
21                node.parent.parent, nodes.ClassDef
22            ):
23                return True
24
25        elif consumer.scope_type == "function" and self._defined_in_function_definition(
26            node, consumer.node
27        ):
28            # If the name node is used as a function default argument's value or as
29            # a decorator, then start from the parent frame of the function instead
30            # of the function frame - and thus open an inner class scope
31            return True
32
33        elif consumer.scope_type == "lambda" and utils.is_default_argument(
34            node, consumer.node
35        ):
36            return True
37
38        return False
            

Path 2: 8414 calls (0.35)

→ node Name (8249) AssignName (161) DelName (4)

→ consumer NamesConsumer (8414)

→ is_start_index True (8103) False (311)

↩ return False (8414)

5 run 9 not run

1def _should_node_be_skipped(
2        self, node: nodes.Name, consumer: NamesConsumer, is_start_index: bool
3    ) -> bool:
4        """Tests a consumer and node for various conditions in which the node shouldn't
5        be checked for the undefined-variable and used-before-assignment checks.
6        """
7        if consumer.scope_type == "class":
8            # The list of base classes in the class definition is not part
9            # of the class body.
10            # If the current scope is a class scope but it's not the inner
11            # scope, ignore it. This prevents to access this scope instead of
12            # the globals one in function members when there are some common
13            # names.
14            if utils.is_ancestor_name(consumer.node, node) or (
15                not is_start_index and self._ignore_class_scope(node)
16            ):
17                return True
18
19            # Ignore inner class scope for keywords in class definition
20            if isinstance(node.parent, nodes.Keyword) and isinstance(
21                node.parent.parent, nodes.ClassDef
22            ):
23                return True
24
25        elif consumer.scope_type == "function" and self._defined_in_function_definition(
26            node, consumer.node
27        ):
28            # If the name node is used as a function default argument's value or as
29            # a decorator, then start from the parent frame of the function instead
30            # of the function frame - and thus open an inner class scope
31            return True
32
33        elif consumer.scope_type == "lambda" and utils.is_default_argument(
34            node, consumer.node
35        ):
36            return True
37
38        return False
            

Path 3: 1518 calls (0.06)

→ node Name (1516) AssignName (2)

→ consumer NamesConsumer (1518)

→ is_start_index False (1518)

↩ return True (1518)

4 run 10 not run

1def _should_node_be_skipped(
2        self, node: nodes.Name, consumer: NamesConsumer, is_start_index: bool
3    ) -> bool:
4        """Tests a consumer and node for various conditions in which the node shouldn't
5        be checked for the undefined-variable and used-before-assignment checks.
6        """
7        if consumer.scope_type == "class":
8            # The list of base classes in the class definition is not part
9            # of the class body.
10            # If the current scope is a class scope but it's not the inner
11            # scope, ignore it. This prevents to access this scope instead of
12            # the globals one in function members when there are some common
13            # names.
14            if utils.is_ancestor_name(consumer.node, node) or (
15                not is_start_index and self._ignore_class_scope(node)
16            ):
17                return True
18
19            # Ignore inner class scope for keywords in class definition
20            if isinstance(node.parent, nodes.Keyword) and isinstance(
21                node.parent.parent, nodes.ClassDef
22            ):
23                return True
24
25        elif consumer.scope_type == "function" and self._defined_in_function_definition(
26            node, consumer.node
27        ):
28            # If the name node is used as a function default argument's value or as
29            # a decorator, then start from the parent frame of the function instead
30            # of the function frame - and thus open an inner class scope
31            return True
32
33        elif consumer.scope_type == "lambda" and utils.is_default_argument(
34            node, consumer.node
35        ):
36            return True
37
38        return False
            

Path 4: 1200 calls (0.05)

→ node Name (1200)

→ consumer NamesConsumer (1200)

→ is_start_index True (1192) False (8)

↩ return True (1200)

4 run 10 not run

1def _should_node_be_skipped(
2        self, node: nodes.Name, consumer: NamesConsumer, is_start_index: bool
3    ) -> bool:
4        """Tests a consumer and node for various conditions in which the node shouldn't
5        be checked for the undefined-variable and used-before-assignment checks.
6        """
7        if consumer.scope_type == "class":
8            # The list of base classes in the class definition is not part
9            # of the class body.
10            # If the current scope is a class scope but it's not the inner
11            # scope, ignore it. This prevents to access this scope instead of
12            # the globals one in function members when there are some common
13            # names.
14            if utils.is_ancestor_name(consumer.node, node) or (
15                not is_start_index and self._ignore_class_scope(node)
16            ):
17                return True
18
19            # Ignore inner class scope for keywords in class definition
20            if isinstance(node.parent, nodes.Keyword) and isinstance(
21                node.parent.parent, nodes.ClassDef
22            ):
23                return True
24
25        elif consumer.scope_type == "function" and self._defined_in_function_definition(
26            node, consumer.node
27        ):
28            # If the name node is used as a function default argument's value or as
29            # a decorator, then start from the parent frame of the function instead
30            # of the function frame - and thus open an inner class scope
31            return True
32
33        elif consumer.scope_type == "lambda" and utils.is_default_argument(
34            node, consumer.node
35        ):
36            return True
37
38        return False
            

Path 5: 678 calls (0.03)

→ node Name (678)

→ consumer NamesConsumer (678)

→ is_start_index True (677) False (1)

↩ return True (678)

3 run 11 not run

1def _should_node_be_skipped(
2        self, node: nodes.Name, consumer: NamesConsumer, is_start_index: bool
3    ) -> bool:
4        """Tests a consumer and node for various conditions in which the node shouldn't
5        be checked for the undefined-variable and used-before-assignment checks.
6        """
7        if consumer.scope_type == "class":
8            # The list of base classes in the class definition is not part
9            # of the class body.
10            # If the current scope is a class scope but it's not the inner
11            # scope, ignore it. This prevents to access this scope instead of
12            # the globals one in function members when there are some common
13            # names.
14            if utils.is_ancestor_name(consumer.node, node) or (
15                not is_start_index and self._ignore_class_scope(node)
16            ):
17                return True
18
19            # Ignore inner class scope for keywords in class definition
20            if isinstance(node.parent, nodes.Keyword) and isinstance(
21                node.parent.parent, nodes.ClassDef
22            ):
23                return True
24
25        elif consumer.scope_type == "function" and self._defined_in_function_definition(
26            node, consumer.node
27        ):
28            # If the name node is used as a function default argument's value or as
29            # a decorator, then start from the parent frame of the function instead
30            # of the function frame - and thus open an inner class scope
31            return True
32
33        elif consumer.scope_type == "lambda" and utils.is_default_argument(
34            node, consumer.node
35        ):
36            return True
37
38        return False
            

Path 6: 557 calls (0.02)

→ node Name (555) AssignName (2)

→ consumer NamesConsumer (557)

→ is_start_index True (501) False (56)

↩ return False (557)

5 run 9 not run

1def _should_node_be_skipped(
2        self, node: nodes.Name, consumer: NamesConsumer, is_start_index: bool
3    ) -> bool:
4        """Tests a consumer and node for various conditions in which the node shouldn't
5        be checked for the undefined-variable and used-before-assignment checks.
6        """
7        if consumer.scope_type == "class":
8            # The list of base classes in the class definition is not part
9            # of the class body.
10            # If the current scope is a class scope but it's not the inner
11            # scope, ignore it. This prevents to access this scope instead of
12            # the globals one in function members when there are some common
13            # names.
14            if utils.is_ancestor_name(consumer.node, node) or (
15                not is_start_index and self._ignore_class_scope(node)
16            ):
17                return True
18
19            # Ignore inner class scope for keywords in class definition
20            if isinstance(node.parent, nodes.Keyword) and isinstance(
21                node.parent.parent, nodes.ClassDef
22            ):
23                return True
24
25        elif consumer.scope_type == "function" and self._defined_in_function_definition(
26            node, consumer.node
27        ):
28            # If the name node is used as a function default argument's value or as
29            # a decorator, then start from the parent frame of the function instead
30            # of the function frame - and thus open an inner class scope
31            return True
32
33        elif consumer.scope_type == "lambda" and utils.is_default_argument(
34            node, consumer.node
35        ):
36            return True
37
38        return False
            

Path 7: 366 calls (0.02)

→ node Name (366)

→ consumer NamesConsumer (366)

→ is_start_index True (353) False (13)

↩ return False (366)

5 run 9 not run

1def _should_node_be_skipped(
2        self, node: nodes.Name, consumer: NamesConsumer, is_start_index: bool
3    ) -> bool:
4        """Tests a consumer and node for various conditions in which the node shouldn't
5        be checked for the undefined-variable and used-before-assignment checks.
6        """
7        if consumer.scope_type == "class":
8            # The list of base classes in the class definition is not part
9            # of the class body.
10            # If the current scope is a class scope but it's not the inner
11            # scope, ignore it. This prevents to access this scope instead of
12            # the globals one in function members when there are some common
13            # names.
14            if utils.is_ancestor_name(consumer.node, node) or (
15                not is_start_index and self._ignore_class_scope(node)
16            ):
17                return True
18
19            # Ignore inner class scope for keywords in class definition
20            if isinstance(node.parent, nodes.Keyword) and isinstance(
21                node.parent.parent, nodes.ClassDef
22            ):
23                return True
24
25        elif consumer.scope_type == "function" and self._defined_in_function_definition(
26            node, consumer.node
27        ):
28            # If the name node is used as a function default argument's value or as
29            # a decorator, then start from the parent frame of the function instead
30            # of the function frame - and thus open an inner class scope
31            return True
32
33        elif consumer.scope_type == "lambda" and utils.is_default_argument(
34            node, consumer.node
35        ):
36            return True
37
38        return False
            

Path 8: 17 calls (0.0)

→ node Name (17)

→ consumer NamesConsumer (17)

→ is_start_index True (17)

↩ return True (17)

5 run 9 not run

1def _should_node_be_skipped(
2        self, node: nodes.Name, consumer: NamesConsumer, is_start_index: bool
3    ) -> bool:
4        """Tests a consumer and node for various conditions in which the node shouldn't
5        be checked for the undefined-variable and used-before-assignment checks.
6        """
7        if consumer.scope_type == "class":
8            # The list of base classes in the class definition is not part
9            # of the class body.
10            # If the current scope is a class scope but it's not the inner
11            # scope, ignore it. This prevents to access this scope instead of
12            # the globals one in function members when there are some common
13            # names.
14            if utils.is_ancestor_name(consumer.node, node) or (
15                not is_start_index and self._ignore_class_scope(node)
16            ):
17                return True
18
19            # Ignore inner class scope for keywords in class definition
20            if isinstance(node.parent, nodes.Keyword) and isinstance(
21                node.parent.parent, nodes.ClassDef
22            ):
23                return True
24
25        elif consumer.scope_type == "function" and self._defined_in_function_definition(
26            node, consumer.node
27        ):
28            # If the name node is used as a function default argument's value or as
29            # a decorator, then start from the parent frame of the function instead
30            # of the function frame - and thus open an inner class scope
31            return True
32
33        elif consumer.scope_type == "lambda" and utils.is_default_argument(
34            node, consumer.node
35        ):
36            return True
37
38        return False
            

Path 9: 9 calls (0.0)

→ node Name (9)

→ consumer NamesConsumer (9)

→ is_start_index True (9)

↩ return False (9)

6 run 8 not run

1def _should_node_be_skipped(
2        self, node: nodes.Name, consumer: NamesConsumer, is_start_index: bool
3    ) -> bool:
4        """Tests a consumer and node for various conditions in which the node shouldn't
5        be checked for the undefined-variable and used-before-assignment checks.
6        """
7        if consumer.scope_type == "class":
8            # The list of base classes in the class definition is not part
9            # of the class body.
10            # If the current scope is a class scope but it's not the inner
11            # scope, ignore it. This prevents to access this scope instead of
12            # the globals one in function members when there are some common
13            # names.
14            if utils.is_ancestor_name(consumer.node, node) or (
15                not is_start_index and self._ignore_class_scope(node)
16            ):
17                return True
18
19            # Ignore inner class scope for keywords in class definition
20            if isinstance(node.parent, nodes.Keyword) and isinstance(
21                node.parent.parent, nodes.ClassDef
22            ):
23                return True
24
25        elif consumer.scope_type == "function" and self._defined_in_function_definition(
26            node, consumer.node
27        ):
28            # If the name node is used as a function default argument's value or as
29            # a decorator, then start from the parent frame of the function instead
30            # of the function frame - and thus open an inner class scope
31            return True
32
33        elif consumer.scope_type == "lambda" and utils.is_default_argument(
34            node, consumer.node
35        ):
36            return True
37
38        return False
            

Path 10: 3 calls (0.0)

→ node Name (3)

→ consumer NamesConsumer (3)

→ is_start_index True (3)

↩ return True (3)

6 run 8 not run

1def _should_node_be_skipped(
2        self, node: nodes.Name, consumer: NamesConsumer, is_start_index: bool
3    ) -> bool:
4        """Tests a consumer and node for various conditions in which the node shouldn't
5        be checked for the undefined-variable and used-before-assignment checks.
6        """
7        if consumer.scope_type == "class":
8            # The list of base classes in the class definition is not part
9            # of the class body.
10            # If the current scope is a class scope but it's not the inner
11            # scope, ignore it. This prevents to access this scope instead of
12            # the globals one in function members when there are some common
13            # names.
14            if utils.is_ancestor_name(consumer.node, node) or (
15                not is_start_index and self._ignore_class_scope(node)
16            ):
17                return True
18
19            # Ignore inner class scope for keywords in class definition
20            if isinstance(node.parent, nodes.Keyword) and isinstance(
21                node.parent.parent, nodes.ClassDef
22            ):
23                return True
24
25        elif consumer.scope_type == "function" and self._defined_in_function_definition(
26            node, consumer.node
27        ):
28            # If the name node is used as a function default argument's value or as
29            # a decorator, then start from the parent frame of the function instead
30            # of the function frame - and thus open an inner class scope
31            return True
32
33        elif consumer.scope_type == "lambda" and utils.is_default_argument(
34            node, consumer.node
35        ):
36            return True
37
38        return False