Path 1: 445 calls (0.73)

Import (445) 

1@utils.only_required_for_messages("no-name-in-module")
2    def visit_import(self, node: nodes.Import) -> None:
3        """Check modules attribute accesses."""
4        if not self._analyse_fallback_blocks and utils.is_from_fallback_block(node):
5            # No need to verify this, since ImportError is already
6            # handled by the client code.
7            return
8        if utils.is_node_in_guarded_import_block(node) is True:
9            # Don't verify import if part of guarded import block
10            # I.e. `sys.version_info` or `typing.TYPE_CHECKING`
11            return
12
13        for name, _ in node.names:
14            parts = name.split(".")
15            try:
16                module = next(_infer_name_module(node, parts[0]))
17            except astroid.ResolveError:
18                continue
19            if not isinstance(module, nodes.Module):
20                continue
21            self._check_module_attrs(node, module, parts[1:])

Path 2: 121 calls (0.2)

Import (121)

InferenceError (121) 

1@utils.only_required_for_messages("no-name-in-module")
2    def visit_import(self, node: nodes.Import) -> None:
3        """Check modules attribute accesses."""
4        if not self._analyse_fallback_blocks and utils.is_from_fallback_block(node):
5            # No need to verify this, since ImportError is already
6            # handled by the client code.
7            return
8        if utils.is_node_in_guarded_import_block(node) is True:
9            # Don't verify import if part of guarded import block
10            # I.e. `sys.version_info` or `typing.TYPE_CHECKING`
11            return
12
13        for name, _ in node.names:
14            parts = name.split(".")
15            try:
16                module = next(_infer_name_module(node, parts[0]))
17            except astroid.ResolveError:
18                continue
19            if not isinstance(module, nodes.Module):
20                continue
21            self._check_module_attrs(node, module, parts[1:])

Path 3: 26 calls (0.04)

Import (26)

None (26) 

1@utils.only_required_for_messages("no-name-in-module")
2    def visit_import(self, node: nodes.Import) -> None:
3        """Check modules attribute accesses."""
4        if not self._analyse_fallback_blocks and utils.is_from_fallback_block(node):
5            # No need to verify this, since ImportError is already
6            # handled by the client code.
7            return
8        if utils.is_node_in_guarded_import_block(node) is True:
9            # Don't verify import if part of guarded import block
10            # I.e. `sys.version_info` or `typing.TYPE_CHECKING`
11            return
12
13        for name, _ in node.names:
14            parts = name.split(".")
15            try:
16                module = next(_infer_name_module(node, parts[0]))
17            except astroid.ResolveError:
18                continue
19            if not isinstance(module, nodes.Module):
20                continue
21            self._check_module_attrs(node, module, parts[1:])

Path 4: 17 calls (0.03)

Import (17)

None (17) 

1@utils.only_required_for_messages("no-name-in-module")
2    def visit_import(self, node: nodes.Import) -> None:
3        """Check modules attribute accesses."""
4        if not self._analyse_fallback_blocks and utils.is_from_fallback_block(node):
5            # No need to verify this, since ImportError is already
6            # handled by the client code.
7            return
8        if utils.is_node_in_guarded_import_block(node) is True:
9            # Don't verify import if part of guarded import block
10            # I.e. `sys.version_info` or `typing.TYPE_CHECKING`
11            return
12
13        for name, _ in node.names:
14            parts = name.split(".")
15            try:
16                module = next(_infer_name_module(node, parts[0]))
17            except astroid.ResolveError:
18                continue
19            if not isinstance(module, nodes.Module):
20                continue
21            self._check_module_attrs(node, module, parts[1:])

Path 5: 1 calls (0.0)

Import (1)

InferenceError (1) 

1@utils.only_required_for_messages("no-name-in-module")
2    def visit_import(self, node: nodes.Import) -> None:
3        """Check modules attribute accesses."""
4        if not self._analyse_fallback_blocks and utils.is_from_fallback_block(node):
5            # No need to verify this, since ImportError is already
6            # handled by the client code.
7            return
8        if utils.is_node_in_guarded_import_block(node) is True:
9            # Don't verify import if part of guarded import block
10            # I.e. `sys.version_info` or `typing.TYPE_CHECKING`
11            return
12
13        for name, _ in node.names:
14            parts = name.split(".")
15            try:
16                module = next(_infer_name_module(node, parts[0]))
17            except astroid.ResolveError:
18                continue
19            if not isinstance(module, nodes.Module):
20                continue
21            self._check_module_attrs(node, module, parts[1:])