Path 1: 11596 calls (0.84)

→ node_type 'argument' (2889) 'function' (1719) 'variable' (1599) 'class' (1519) 'method' (1309) 'module' (1081) 'attr' (427) 'class_attribute' (420) 'const' (319...

→ name 'self' (1384) '__init__' (253) 'value' (147) 'arg' (128) 'cls' (125) 'var' (123) 'func' (112) 'test' (112) 'x' (93) 'my_func' (87)

→ node AssignName (5604) FunctionDef (3062) ClassDef (1432) Module (1081) AssignAttr (274) Unknown (69) AsyncFunctionDef (50) Global (24)

→ confidence Confidence (11596)

→ disallowed_check_only False (11212) True (384)

9 run 18 not run

1def _check_name(
2        self,
3        node_type: str,
4        name: str,
5        node: nodes.NodeNG,
6        confidence: interfaces.Confidence = interfaces.HIGH,
7        disallowed_check_only: bool = False,
8    ) -> None:
9        """Check for a name using the type's regexp."""
10
11        def _should_exempt_from_invalid_name(node: nodes.NodeNG) -> bool:
12            if node_type == "variable":
13                inferred = utils.safe_infer(node)
14                if isinstance(inferred, nodes.ClassDef):
15                    return True
16            return False
17
18        if self._name_allowed_by_regex(name=name):
19            return
20        if self._name_disallowed_by_regex(name=name):
21            self.linter.stats.increase_bad_name(node_type, 1)
22            self.add_message(
23                "disallowed-name", node=node, args=name, confidence=interfaces.HIGH
24            )
25            return
26        regexp = self._name_regexps[node_type]
27        match = regexp.match(name)
28
29        if _is_multi_naming_match(match, node_type, confidence):
30            name_group = self._find_name_group(node_type)
31            bad_name_group = self._bad_names.setdefault(name_group, {})
32            # Ignored because this is checked by the if statement
33            warnings = bad_name_group.setdefault(match.lastgroup, [])  # type: ignore[union-attr, arg-type]
34            warnings.append((node, node_type, name, confidence))
35
36        if (
37            match is None
38            and not disallowed_check_only
39            and not _should_exempt_from_invalid_name(node)
40        ):
41            self._raise_name_warning(None, node, node_type, name, confidence)
42
43        # Check TypeVar names for variance suffixes
44        if node_type == "typevar":
45            self._check_typevar(name, node)
            

Path 2: 1099 calls (0.08)

→ node_type 'variable' (308) 'const' (273) 'argument' (271) 'class' (95) 'function' (42) 'attr' (32) 'method' (29) 'module' (25) 'class_const' (23) 'class_attribu...

→ name 'x' (160) 'a' (115) 'y' (83) 'b' (82) 'c' (57) 'z' (53) 'result' (31) 'A' (30) 'value' (25) 'd' (23)

→ node AssignName (876) ClassDef (86) FunctionDef (76) Module (25) AssignAttr (24) Global (9) Unknown (3)

→ confidence Confidence (1099)

→ disallowed_check_only False (1099)

12 run 15 not run

1def _check_name(
2        self,
3        node_type: str,
4        name: str,
5        node: nodes.NodeNG,
6        confidence: interfaces.Confidence = interfaces.HIGH,
7        disallowed_check_only: bool = False,
8    ) -> None:
9        """Check for a name using the type's regexp."""
10
11        def _should_exempt_from_invalid_name(node: nodes.NodeNG) -> bool:
12            if node_type == "variable":
13                inferred = utils.safe_infer(node)
14                if isinstance(inferred, nodes.ClassDef):
15                    return True
16            return False
17
18        if self._name_allowed_by_regex(name=name):
19            return
20        if self._name_disallowed_by_regex(name=name):
21            self.linter.stats.increase_bad_name(node_type, 1)
22            self.add_message(
23                "disallowed-name", node=node, args=name, confidence=interfaces.HIGH
24            )
25            return
26        regexp = self._name_regexps[node_type]
27        match = regexp.match(name)
28
29        if _is_multi_naming_match(match, node_type, confidence):
30            name_group = self._find_name_group(node_type)
31            bad_name_group = self._bad_names.setdefault(name_group, {})
32            # Ignored because this is checked by the if statement
33            warnings = bad_name_group.setdefault(match.lastgroup, [])  # type: ignore[union-attr, arg-type]
34            warnings.append((node, node_type, name, confidence))
35
36        if (
37            match is None
38            and not disallowed_check_only
39            and not _should_exempt_from_invalid_name(node)
40        ):
41            self._raise_name_warning(None, node, node_type, name, confidence)
42
43        # Check TypeVar names for variance suffixes
44        if node_type == "typevar":
45            self._check_typevar(name, node)
            

Path 3: 476 calls (0.03)

→ node_type 'variable' (476)

→ name 'x' (55) 'a' (43) 'b' (31) 'FIRST' (16) 'd' (14) 'c' (10) 'z' (7) 'y' (7) 'SECOND' (7) 'CustomTypedDict1' (6)

→ node AssignName (476)

→ confidence Confidence (476)

→ disallowed_check_only True (476)

10 run 17 not run

1def _check_name(
2        self,
3        node_type: str,
4        name: str,
5        node: nodes.NodeNG,
6        confidence: interfaces.Confidence = interfaces.HIGH,
7        disallowed_check_only: bool = False,
8    ) -> None:
9        """Check for a name using the type's regexp."""
10
11        def _should_exempt_from_invalid_name(node: nodes.NodeNG) -> bool:
12            if node_type == "variable":
13                inferred = utils.safe_infer(node)
14                if isinstance(inferred, nodes.ClassDef):
15                    return True
16            return False
17
18        if self._name_allowed_by_regex(name=name):
19            return
20        if self._name_disallowed_by_regex(name=name):
21            self.linter.stats.increase_bad_name(node_type, 1)
22            self.add_message(
23                "disallowed-name", node=node, args=name, confidence=interfaces.HIGH
24            )
25            return
26        regexp = self._name_regexps[node_type]
27        match = regexp.match(name)
28
29        if _is_multi_naming_match(match, node_type, confidence):
30            name_group = self._find_name_group(node_type)
31            bad_name_group = self._bad_names.setdefault(name_group, {})
32            # Ignored because this is checked by the if statement
33            warnings = bad_name_group.setdefault(match.lastgroup, [])  # type: ignore[union-attr, arg-type]
34            warnings.append((node, node_type, name, confidence))
35
36        if (
37            match is None
38            and not disallowed_check_only
39            and not _should_exempt_from_invalid_name(node)
40        ):
41            self._raise_name_warning(None, node, node_type, name, confidence)
42
43        # Check TypeVar names for variance suffixes
44        if node_type == "typevar":
45            self._check_typevar(name, node)
            

Path 4: 397 calls (0.03)

→ node_type 'variable' (262) 'inlinevar' (67) 'argument' (37) 'const' (10) 'method' (9) 'function' (8) 'class_attribute' (2) 'attr' (2)

→ name '_' (159) 'i' (144) 'k' (71) 'j' (17) 'ex' (5) 'ignored_SOME_CONSTANT' (1)

→ node AssignName (378) FunctionDef (19)

→ confidence Confidence (397)

→ disallowed_check_only False (350) True (47)

↩ return None (397)

3 run 24 not run

1def _check_name(
2        self,
3        node_type: str,
4        name: str,
5        node: nodes.NodeNG,
6        confidence: interfaces.Confidence = interfaces.HIGH,
7        disallowed_check_only: bool = False,
8    ) -> None:
9        """Check for a name using the type's regexp."""
10
11        def _should_exempt_from_invalid_name(node: nodes.NodeNG) -> bool:
12            if node_type == "variable":
13                inferred = utils.safe_infer(node)
14                if isinstance(inferred, nodes.ClassDef):
15                    return True
16            return False
17
18        if self._name_allowed_by_regex(name=name):
19            return
20        if self._name_disallowed_by_regex(name=name):
21            self.linter.stats.increase_bad_name(node_type, 1)
22            self.add_message(
23                "disallowed-name", node=node, args=name, confidence=interfaces.HIGH
24            )
25            return
26        regexp = self._name_regexps[node_type]
27        match = regexp.match(name)
28
29        if _is_multi_naming_match(match, node_type, confidence):
30            name_group = self._find_name_group(node_type)
31            bad_name_group = self._bad_names.setdefault(name_group, {})
32            # Ignored because this is checked by the if statement
33            warnings = bad_name_group.setdefault(match.lastgroup, [])  # type: ignore[union-attr, arg-type]
34            warnings.append((node, node_type, name, confidence))
35
36        if (
37            match is None
38            and not disallowed_check_only
39            and not _should_exempt_from_invalid_name(node)
40        ):
41            self._raise_name_warning(None, node, node_type, name, confidence)
42
43        # Check TypeVar names for variance suffixes
44        if node_type == "typevar":
45            self._check_typevar(name, node)
            

Path 5: 103 calls (0.01)

→ node_type 'typevar' (103)

→ name 'T' (12) 'T_co' (9) 'VT_contra' (9) 'T_contra' (8) 'VT' (7) 'VT_co' (7) 'X_co' (5) 'X_contra' (5) 'X' (4) 'TypeT' (2)

→ node AssignName (103)

→ confidence Confidence (103)

→ disallowed_check_only False (103)

10 run 17 not run

1def _check_name(
2        self,
3        node_type: str,
4        name: str,
5        node: nodes.NodeNG,
6        confidence: interfaces.Confidence = interfaces.HIGH,
7        disallowed_check_only: bool = False,
8    ) -> None:
9        """Check for a name using the type's regexp."""
10
11        def _should_exempt_from_invalid_name(node: nodes.NodeNG) -> bool:
12            if node_type == "variable":
13                inferred = utils.safe_infer(node)
14                if isinstance(inferred, nodes.ClassDef):
15                    return True
16            return False
17
18        if self._name_allowed_by_regex(name=name):
19            return
20        if self._name_disallowed_by_regex(name=name):
21            self.linter.stats.increase_bad_name(node_type, 1)
22            self.add_message(
23                "disallowed-name", node=node, args=name, confidence=interfaces.HIGH
24            )
25            return
26        regexp = self._name_regexps[node_type]
27        match = regexp.match(name)
28
29        if _is_multi_naming_match(match, node_type, confidence):
30            name_group = self._find_name_group(node_type)
31            bad_name_group = self._bad_names.setdefault(name_group, {})
32            # Ignored because this is checked by the if statement
33            warnings = bad_name_group.setdefault(match.lastgroup, [])  # type: ignore[union-attr, arg-type]
34            warnings.append((node, node_type, name, confidence))
35
36        if (
37            match is None
38            and not disallowed_check_only
39            and not _should_exempt_from_invalid_name(node)
40        ):
41            self._raise_name_warning(None, node, node_type, name, confidence)
42
43        # Check TypeVar names for variance suffixes
44        if node_type == "typevar":
45            self._check_typevar(name, node)
            

Path 6: 62 calls (0.0)

→ node_type 'function' (20) 'attr' (15) 'method' (7) 'variable' (6) 'argument' (5) 'const' (4) 'class' (2) 'module' (2) 'class_attribute' (1)

→ name 'foo' (40) 'bar' (16) 'baz' (3) 'explicit_bad_some_constant' (1) 'disallowed_2_snake_case' (1) 'toto' (1)

→ node FunctionDef (40) AssignName (15) ClassDef (2) Module (2) AsyncFunctionDef (1) Global (1) AssignAttr (1)

→ confidence Confidence (62)

→ disallowed_check_only False (58) True (4)

↩ return None (62)

7 run 20 not run

1def _check_name(
2        self,
3        node_type: str,
4        name: str,
5        node: nodes.NodeNG,
6        confidence: interfaces.Confidence = interfaces.HIGH,
7        disallowed_check_only: bool = False,
8    ) -> None:
9        """Check for a name using the type's regexp."""
10
11        def _should_exempt_from_invalid_name(node: nodes.NodeNG) -> bool:
12            if node_type == "variable":
13                inferred = utils.safe_infer(node)
14                if isinstance(inferred, nodes.ClassDef):
15                    return True
16            return False
17
18        if self._name_allowed_by_regex(name=name):
19            return
20        if self._name_disallowed_by_regex(name=name):
21            self.linter.stats.increase_bad_name(node_type, 1)
22            self.add_message(
23                "disallowed-name", node=node, args=name, confidence=interfaces.HIGH
24            )
25            return
26        regexp = self._name_regexps[node_type]
27        match = regexp.match(name)
28
29        if _is_multi_naming_match(match, node_type, confidence):
30            name_group = self._find_name_group(node_type)
31            bad_name_group = self._bad_names.setdefault(name_group, {})
32            # Ignored because this is checked by the if statement
33            warnings = bad_name_group.setdefault(match.lastgroup, [])  # type: ignore[union-attr, arg-type]
34            warnings.append((node, node_type, name, confidence))
35
36        if (
37            match is None
38            and not disallowed_check_only
39            and not _should_exempt_from_invalid_name(node)
40        ):
41            self._raise_name_warning(None, node, node_type, name, confidence)
42
43        # Check TypeVar names for variance suffixes
44        if node_type == "typevar":
45            self._check_typevar(name, node)
            

Path 7: 18 calls (0.0)

→ node_type 'typevar' (18)

→ name 'badName' (2) 'GoodNameT' (2) 'GoodNameT_co' (2) 'TYPE' (1) 'T2' (1) 'CALLABLE_T' (1) 'DeviceType' (1) 'IPAddressU' (1) 'TAnyStr' (1) 'badName_co' (1)...

→ node AssignName (18)

→ confidence Confidence (18)

→ disallowed_check_only False (18)

13 run 14 not run

1def _check_name(
2        self,
3        node_type: str,
4        name: str,
5        node: nodes.NodeNG,
6        confidence: interfaces.Confidence = interfaces.HIGH,
7        disallowed_check_only: bool = False,
8    ) -> None:
9        """Check for a name using the type's regexp."""
10
11        def _should_exempt_from_invalid_name(node: nodes.NodeNG) -> bool:
12            if node_type == "variable":
13                inferred = utils.safe_infer(node)
14                if isinstance(inferred, nodes.ClassDef):
15                    return True
16            return False
17
18        if self._name_allowed_by_regex(name=name):
19            return
20        if self._name_disallowed_by_regex(name=name):
21            self.linter.stats.increase_bad_name(node_type, 1)
22            self.add_message(
23                "disallowed-name", node=node, args=name, confidence=interfaces.HIGH
24            )
25            return
26        regexp = self._name_regexps[node_type]
27        match = regexp.match(name)
28
29        if _is_multi_naming_match(match, node_type, confidence):
30            name_group = self._find_name_group(node_type)
31            bad_name_group = self._bad_names.setdefault(name_group, {})
32            # Ignored because this is checked by the if statement
33            warnings = bad_name_group.setdefault(match.lastgroup, [])  # type: ignore[union-attr, arg-type]
34            warnings.append((node, node_type, name, confidence))
35
36        if (
37            match is None
38            and not disallowed_check_only
39            and not _should_exempt_from_invalid_name(node)
40        ):
41            self._raise_name_warning(None, node, node_type, name, confidence)
42
43        # Check TypeVar names for variance suffixes
44        if node_type == "typevar":
45            self._check_typevar(name, node)
            

Path 8: 12 calls (0.0)

→ node_type 'function' (6) 'class' (5) 'method' (1)

→ name 'UPPER' (2) 'lower' (2) 'classb' (2) 'CLASSC' (2) 'anotherlower' (1) 'CLASSA' (1) 'func' (1) 'FUNC' (1)

→ node FunctionDef (7) ClassDef (5)

→ confidence Confidence (12)

→ disallowed_check_only False (12)

13 run 14 not run

1def _check_name(
2        self,
3        node_type: str,
4        name: str,
5        node: nodes.NodeNG,
6        confidence: interfaces.Confidence = interfaces.HIGH,
7        disallowed_check_only: bool = False,
8    ) -> None:
9        """Check for a name using the type's regexp."""
10
11        def _should_exempt_from_invalid_name(node: nodes.NodeNG) -> bool:
12            if node_type == "variable":
13                inferred = utils.safe_infer(node)
14                if isinstance(inferred, nodes.ClassDef):
15                    return True
16            return False
17
18        if self._name_allowed_by_regex(name=name):
19            return
20        if self._name_disallowed_by_regex(name=name):
21            self.linter.stats.increase_bad_name(node_type, 1)
22            self.add_message(
23                "disallowed-name", node=node, args=name, confidence=interfaces.HIGH
24            )
25            return
26        regexp = self._name_regexps[node_type]
27        match = regexp.match(name)
28
29        if _is_multi_naming_match(match, node_type, confidence):
30            name_group = self._find_name_group(node_type)
31            bad_name_group = self._bad_names.setdefault(name_group, {})
32            # Ignored because this is checked by the if statement
33            warnings = bad_name_group.setdefault(match.lastgroup, [])  # type: ignore[union-attr, arg-type]
34            warnings.append((node, node_type, name, confidence))
35
36        if (
37            match is None
38            and not disallowed_check_only
39            and not _should_exempt_from_invalid_name(node)
40        ):
41            self._raise_name_warning(None, node, node_type, name, confidence)
42
43        # Check TypeVar names for variance suffixes
44        if node_type == "typevar":
45            self._check_typevar(name, node)
            

Path 9: 3 calls (0.0)

→ node_type 'variable' (3)

→ name 'TestCase' (1) 'AliasInvalid2' (1) 'Example' (1)

→ node AssignName (3)

→ confidence Confidence (3)

→ disallowed_check_only False (3)

11 run 16 not run

1def _check_name(
2        self,
3        node_type: str,
4        name: str,
5        node: nodes.NodeNG,
6        confidence: interfaces.Confidence = interfaces.HIGH,
7        disallowed_check_only: bool = False,
8    ) -> None:
9        """Check for a name using the type's regexp."""
10
11        def _should_exempt_from_invalid_name(node: nodes.NodeNG) -> bool:
12            if node_type == "variable":
13                inferred = utils.safe_infer(node)
14                if isinstance(inferred, nodes.ClassDef):
15                    return True
16            return False
17
18        if self._name_allowed_by_regex(name=name):
19            return
20        if self._name_disallowed_by_regex(name=name):
21            self.linter.stats.increase_bad_name(node_type, 1)
22            self.add_message(
23                "disallowed-name", node=node, args=name, confidence=interfaces.HIGH
24            )
25            return
26        regexp = self._name_regexps[node_type]
27        match = regexp.match(name)
28
29        if _is_multi_naming_match(match, node_type, confidence):
30            name_group = self._find_name_group(node_type)
31            bad_name_group = self._bad_names.setdefault(name_group, {})
32            # Ignored because this is checked by the if statement
33            warnings = bad_name_group.setdefault(match.lastgroup, [])  # type: ignore[union-attr, arg-type]
34            warnings.append((node, node_type, name, confidence))
35
36        if (
37            match is None
38            and not disallowed_check_only
39            and not _should_exempt_from_invalid_name(node)
40        ):
41            self._raise_name_warning(None, node, node_type, name, confidence)
42
43        # Check TypeVar names for variance suffixes
44        if node_type == "typevar":
45            self._check_typevar(name, node)