Path 1: 437 calls (0.67)

→ node ImportFrom (437)

19 run 2 not run

1def visit_importfrom(self, node: nodes.ImportFrom) -> None:
2        """Triggered when a from statement is seen."""
3        basename = node.modname
4        imported_module = self._get_imported_module(node, basename)
5        absolute_name = get_import_name(node, basename)
6
7        self._check_import_as_rename(node)
8        self._check_misplaced_future(node)
9        self.check_deprecated_module(node, absolute_name)
10        self._check_preferred_module(node, basename)
11        self._check_wildcard_imports(node, imported_module)
12        self._check_same_line_imports(node)
13        self._check_reimport(node, basename=basename, level=node.level)
14        self._check_toplevel(node)
15
16        if isinstance(node.parent, nodes.Module):
17            # Allow imports nested
18            self._check_position(node)
19        if isinstance(node.scope(), nodes.Module):
20            self._record_import(node, imported_module)
21        if imported_module is None:
22            return
23        for name, _ in node.names:
24            if name != "*":
25                self._add_imported_module(node, f"{imported_module.name}.{name}")
26            else:
27                self._add_imported_module(node, imported_module.name)
            

Path 2: 125 calls (0.19)

→ node ImportFrom (125)

↩ return None (125)

17 run 4 not run

1def visit_importfrom(self, node: nodes.ImportFrom) -> None:
2        """Triggered when a from statement is seen."""
3        basename = node.modname
4        imported_module = self._get_imported_module(node, basename)
5        absolute_name = get_import_name(node, basename)
6
7        self._check_import_as_rename(node)
8        self._check_misplaced_future(node)
9        self.check_deprecated_module(node, absolute_name)
10        self._check_preferred_module(node, basename)
11        self._check_wildcard_imports(node, imported_module)
12        self._check_same_line_imports(node)
13        self._check_reimport(node, basename=basename, level=node.level)
14        self._check_toplevel(node)
15
16        if isinstance(node.parent, nodes.Module):
17            # Allow imports nested
18            self._check_position(node)
19        if isinstance(node.scope(), nodes.Module):
20            self._record_import(node, imported_module)
21        if imported_module is None:
22            return
23        for name, _ in node.names:
24            if name != "*":
25                self._add_imported_module(node, f"{imported_module.name}.{name}")
26            else:
27                self._add_imported_module(node, imported_module.name)
            

Path 3: 46 calls (0.07)

→ node ImportFrom (46)

18 run 3 not run

1def visit_importfrom(self, node: nodes.ImportFrom) -> None:
2        """Triggered when a from statement is seen."""
3        basename = node.modname
4        imported_module = self._get_imported_module(node, basename)
5        absolute_name = get_import_name(node, basename)
6
7        self._check_import_as_rename(node)
8        self._check_misplaced_future(node)
9        self.check_deprecated_module(node, absolute_name)
10        self._check_preferred_module(node, basename)
11        self._check_wildcard_imports(node, imported_module)
12        self._check_same_line_imports(node)
13        self._check_reimport(node, basename=basename, level=node.level)
14        self._check_toplevel(node)
15
16        if isinstance(node.parent, nodes.Module):
17            # Allow imports nested
18            self._check_position(node)
19        if isinstance(node.scope(), nodes.Module):
20            self._record_import(node, imported_module)
21        if imported_module is None:
22            return
23        for name, _ in node.names:
24            if name != "*":
25                self._add_imported_module(node, f"{imported_module.name}.{name}")
26            else:
27                self._add_imported_module(node, imported_module.name)
            

Path 4: 28 calls (0.04)

→ node ImportFrom (28)

17 run 4 not run

1def visit_importfrom(self, node: nodes.ImportFrom) -> None:
2        """Triggered when a from statement is seen."""
3        basename = node.modname
4        imported_module = self._get_imported_module(node, basename)
5        absolute_name = get_import_name(node, basename)
6
7        self._check_import_as_rename(node)
8        self._check_misplaced_future(node)
9        self.check_deprecated_module(node, absolute_name)
10        self._check_preferred_module(node, basename)
11        self._check_wildcard_imports(node, imported_module)
12        self._check_same_line_imports(node)
13        self._check_reimport(node, basename=basename, level=node.level)
14        self._check_toplevel(node)
15
16        if isinstance(node.parent, nodes.Module):
17            # Allow imports nested
18            self._check_position(node)
19        if isinstance(node.scope(), nodes.Module):
20            self._record_import(node, imported_module)
21        if imported_module is None:
22            return
23        for name, _ in node.names:
24            if name != "*":
25                self._add_imported_module(node, f"{imported_module.name}.{name}")
26            else:
27                self._add_imported_module(node, imported_module.name)
            

Path 5: 10 calls (0.02)

→ node ImportFrom (10)

19 run 2 not run

1def visit_importfrom(self, node: nodes.ImportFrom) -> None:
2        """Triggered when a from statement is seen."""
3        basename = node.modname
4        imported_module = self._get_imported_module(node, basename)
5        absolute_name = get_import_name(node, basename)
6
7        self._check_import_as_rename(node)
8        self._check_misplaced_future(node)
9        self.check_deprecated_module(node, absolute_name)
10        self._check_preferred_module(node, basename)
11        self._check_wildcard_imports(node, imported_module)
12        self._check_same_line_imports(node)
13        self._check_reimport(node, basename=basename, level=node.level)
14        self._check_toplevel(node)
15
16        if isinstance(node.parent, nodes.Module):
17            # Allow imports nested
18            self._check_position(node)
19        if isinstance(node.scope(), nodes.Module):
20            self._record_import(node, imported_module)
21        if imported_module is None:
22            return
23        for name, _ in node.names:
24            if name != "*":
25                self._add_imported_module(node, f"{imported_module.name}.{name}")
26            else:
27                self._add_imported_module(node, imported_module.name)
            

Path 6: 7 calls (0.01)

→ node ImportFrom (7)

↩ return None (7)

16 run 5 not run

1def visit_importfrom(self, node: nodes.ImportFrom) -> None:
2        """Triggered when a from statement is seen."""
3        basename = node.modname
4        imported_module = self._get_imported_module(node, basename)
5        absolute_name = get_import_name(node, basename)
6
7        self._check_import_as_rename(node)
8        self._check_misplaced_future(node)
9        self.check_deprecated_module(node, absolute_name)
10        self._check_preferred_module(node, basename)
11        self._check_wildcard_imports(node, imported_module)
12        self._check_same_line_imports(node)
13        self._check_reimport(node, basename=basename, level=node.level)
14        self._check_toplevel(node)
15
16        if isinstance(node.parent, nodes.Module):
17            # Allow imports nested
18            self._check_position(node)
19        if isinstance(node.scope(), nodes.Module):
20            self._record_import(node, imported_module)
21        if imported_module is None:
22            return
23        for name, _ in node.names:
24            if name != "*":
25                self._add_imported_module(node, f"{imported_module.name}.{name}")
26            else:
27                self._add_imported_module(node, imported_module.name)
            

Path 7: 4 calls (0.01)

→ node ImportFrom (4)

↩ return None (4)

15 run 6 not run

1def visit_importfrom(self, node: nodes.ImportFrom) -> None:
2        """Triggered when a from statement is seen."""
3        basename = node.modname
4        imported_module = self._get_imported_module(node, basename)
5        absolute_name = get_import_name(node, basename)
6
7        self._check_import_as_rename(node)
8        self._check_misplaced_future(node)
9        self.check_deprecated_module(node, absolute_name)
10        self._check_preferred_module(node, basename)
11        self._check_wildcard_imports(node, imported_module)
12        self._check_same_line_imports(node)
13        self._check_reimport(node, basename=basename, level=node.level)
14        self._check_toplevel(node)
15
16        if isinstance(node.parent, nodes.Module):
17            # Allow imports nested
18            self._check_position(node)
19        if isinstance(node.scope(), nodes.Module):
20            self._record_import(node, imported_module)
21        if imported_module is None:
22            return
23        for name, _ in node.names:
24            if name != "*":
25                self._add_imported_module(node, f"{imported_module.name}.{name}")
26            else:
27                self._add_imported_module(node, imported_module.name)