Path 1: 457 calls (0.71)

→ node ImportFrom (457)

10 run 6 not run

1@utils.only_required_for_messages("no-name-in-module")
2    def visit_importfrom(self, node: nodes.ImportFrom) -> 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        name_parts = node.modname.split(".")
14        try:
15            module = node.do_import_module(name_parts[0])
16        except astroid.AstroidBuildingException:
17            return
18        module = self._check_module_attrs(node, module, name_parts[1:])
19        if not module:
20            return
21        for name, _ in node.names:
22            if name == "*":
23                continue
24            self._check_module_attrs(node, module, name.split("."))
            

Path 2: 119 calls (0.19)

→ node ImportFrom (119)

↩ return None (119)

⚠ exception AstroidImportError (115) TooManyLevelsError (3) AstroidSyntaxError (1)

7 run 9 not run

1@utils.only_required_for_messages("no-name-in-module")
2    def visit_importfrom(self, node: nodes.ImportFrom) -> 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        name_parts = node.modname.split(".")
14        try:
15            module = node.do_import_module(name_parts[0])
16        except astroid.AstroidBuildingException:
17            return
18        module = self._check_module_attrs(node, module, name_parts[1:])
19        if not module:
20            return
21        for name, _ in node.names:
22            if name == "*":
23                continue
24            self._check_module_attrs(node, module, name.split("."))
            

Path 3: 32 calls (0.05)

→ node ImportFrom (32)

↩ return None (32)

3 run 13 not run

1@utils.only_required_for_messages("no-name-in-module")
2    def visit_importfrom(self, node: nodes.ImportFrom) -> 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        name_parts = node.modname.split(".")
14        try:
15            module = node.do_import_module(name_parts[0])
16        except astroid.AstroidBuildingException:
17            return
18        module = self._check_module_attrs(node, module, name_parts[1:])
19        if not module:
20            return
21        for name, _ in node.names:
22            if name == "*":
23                continue
24            self._check_module_attrs(node, module, name.split("."))
            

Path 4: 14 calls (0.02)

→ node ImportFrom (14)

↩ return None (14)

2 run 14 not run

1@utils.only_required_for_messages("no-name-in-module")
2    def visit_importfrom(self, node: nodes.ImportFrom) -> 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        name_parts = node.modname.split(".")
14        try:
15            module = node.do_import_module(name_parts[0])
16        except astroid.AstroidBuildingException:
17            return
18        module = self._check_module_attrs(node, module, name_parts[1:])
19        if not module:
20            return
21        for name, _ in node.names:
22            if name == "*":
23                continue
24            self._check_module_attrs(node, module, name.split("."))
            

Path 5: 10 calls (0.02)

→ node ImportFrom (10)

↩ return None (10)

8 run 8 not run

1@utils.only_required_for_messages("no-name-in-module")
2    def visit_importfrom(self, node: nodes.ImportFrom) -> 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        name_parts = node.modname.split(".")
14        try:
15            module = node.do_import_module(name_parts[0])
16        except astroid.AstroidBuildingException:
17            return
18        module = self._check_module_attrs(node, module, name_parts[1:])
19        if not module:
20            return
21        for name, _ in node.names:
22            if name == "*":
23                continue
24            self._check_module_attrs(node, module, name.split("."))
            

Path 6: 8 calls (0.01)

→ node ImportFrom (8)

10 run 6 not run

1@utils.only_required_for_messages("no-name-in-module")
2    def visit_importfrom(self, node: nodes.ImportFrom) -> 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        name_parts = node.modname.split(".")
14        try:
15            module = node.do_import_module(name_parts[0])
16        except astroid.AstroidBuildingException:
17            return
18        module = self._check_module_attrs(node, module, name_parts[1:])
19        if not module:
20            return
21        for name, _ in node.names:
22            if name == "*":
23                continue
24            self._check_module_attrs(node, module, name.split("."))