Path 1: 667 calls (0.59)

Module (667) 

1def leave_module(self, node: nodes.Module) -> None:
2        # Check imports are grouped by category (standard, 3rd party, local)
3        std_imports, ext_imports, loc_imports = self._check_imports_order(node)
4
5        # Check that imports are grouped by package within a given category
6        met_import: set[str] = set()  # set for 'import x' style
7        met_from: set[str] = set()  # set for 'from x import y' style
8        current_package = None
9        for import_node, import_name in std_imports + ext_imports + loc_imports:
10            met = met_from if isinstance(import_node, nodes.ImportFrom) else met_import
11            package, _, _ = import_name.partition(".")
12            if (
13                current_package
14                and current_package != package
15                and package in met
16                and is_node_in_guarded_import_block(import_node) is False
17            ):
18                self.add_message("ungrouped-imports", node=import_node, args=package)
19            current_package = package
20            if not self.linter.is_message_enabled(
21                "ungrouped-imports", import_node.fromlineno
22            ):
23                continue
24            met.add(package)
25
26        self._imports_stack = []
27        self._first_non_import_node = None

Path 2: 239 calls (0.21)

Module (239) 

1def leave_module(self, node: nodes.Module) -> None:
2        # Check imports are grouped by category (standard, 3rd party, local)
3        std_imports, ext_imports, loc_imports = self._check_imports_order(node)
4
5        # Check that imports are grouped by package within a given category
6        met_import: set[str] = set()  # set for 'import x' style
7        met_from: set[str] = set()  # set for 'from x import y' style
8        current_package = None
9        for import_node, import_name in std_imports + ext_imports + loc_imports:
10            met = met_from if isinstance(import_node, nodes.ImportFrom) else met_import
11            package, _, _ = import_name.partition(".")
12            if (
13                current_package
14                and current_package != package
15                and package in met
16                and is_node_in_guarded_import_block(import_node) is False
17            ):
18                self.add_message("ungrouped-imports", node=import_node, args=package)
19            current_package = package
20            if not self.linter.is_message_enabled(
21                "ungrouped-imports", import_node.fromlineno
22            ):
23                continue
24            met.add(package)
25
26        self._imports_stack = []
27        self._first_non_import_node = None

Path 3: 165 calls (0.15)

Module (165) 

1def leave_module(self, node: nodes.Module) -> None:
2        # Check imports are grouped by category (standard, 3rd party, local)
3        std_imports, ext_imports, loc_imports = self._check_imports_order(node)
4
5        # Check that imports are grouped by package within a given category
6        met_import: set[str] = set()  # set for 'import x' style
7        met_from: set[str] = set()  # set for 'from x import y' style
8        current_package = None
9        for import_node, import_name in std_imports + ext_imports + loc_imports:
10            met = met_from if isinstance(import_node, nodes.ImportFrom) else met_import
11            package, _, _ = import_name.partition(".")
12            if (
13                current_package
14                and current_package != package
15                and package in met
16                and is_node_in_guarded_import_block(import_node) is False
17            ):
18                self.add_message("ungrouped-imports", node=import_node, args=package)
19            current_package = package
20            if not self.linter.is_message_enabled(
21                "ungrouped-imports", import_node.fromlineno
22            ):
23                continue
24            met.add(package)
25
26        self._imports_stack = []
27        self._first_non_import_node = None

Path 4: 19 calls (0.02)

Module (19) 

1def leave_module(self, node: nodes.Module) -> None:
2        # Check imports are grouped by category (standard, 3rd party, local)
3        std_imports, ext_imports, loc_imports = self._check_imports_order(node)
4
5        # Check that imports are grouped by package within a given category
6        met_import: set[str] = set()  # set for 'import x' style
7        met_from: set[str] = set()  # set for 'from x import y' style
8        current_package = None
9        for import_node, import_name in std_imports + ext_imports + loc_imports:
10            met = met_from if isinstance(import_node, nodes.ImportFrom) else met_import
11            package, _, _ = import_name.partition(".")
12            if (
13                current_package
14                and current_package != package
15                and package in met
16                and is_node_in_guarded_import_block(import_node) is False
17            ):
18                self.add_message("ungrouped-imports", node=import_node, args=package)
19            current_package = package
20            if not self.linter.is_message_enabled(
21                "ungrouped-imports", import_node.fromlineno
22            ):
23                continue
24            met.add(package)
25
26        self._imports_stack = []
27        self._first_non_import_node = None

Path 5: 19 calls (0.02)

Module (19) 

1def leave_module(self, node: nodes.Module) -> None:
2        # Check imports are grouped by category (standard, 3rd party, local)
3        std_imports, ext_imports, loc_imports = self._check_imports_order(node)
4
5        # Check that imports are grouped by package within a given category
6        met_import: set[str] = set()  # set for 'import x' style
7        met_from: set[str] = set()  # set for 'from x import y' style
8        current_package = None
9        for import_node, import_name in std_imports + ext_imports + loc_imports:
10            met = met_from if isinstance(import_node, nodes.ImportFrom) else met_import
11            package, _, _ = import_name.partition(".")
12            if (
13                current_package
14                and current_package != package
15                and package in met
16                and is_node_in_guarded_import_block(import_node) is False
17            ):
18                self.add_message("ungrouped-imports", node=import_node, args=package)
19            current_package = package
20            if not self.linter.is_message_enabled(
21                "ungrouped-imports", import_node.fromlineno
22            ):
23                continue
24            met.add(package)
25
26        self._imports_stack = []
27        self._first_non_import_node = None

Path 6: 18 calls (0.02)

Module (18) 

1def leave_module(self, node: nodes.Module) -> None:
2        # Check imports are grouped by category (standard, 3rd party, local)
3        std_imports, ext_imports, loc_imports = self._check_imports_order(node)
4
5        # Check that imports are grouped by package within a given category
6        met_import: set[str] = set()  # set for 'import x' style
7        met_from: set[str] = set()  # set for 'from x import y' style
8        current_package = None
9        for import_node, import_name in std_imports + ext_imports + loc_imports:
10            met = met_from if isinstance(import_node, nodes.ImportFrom) else met_import
11            package, _, _ = import_name.partition(".")
12            if (
13                current_package
14                and current_package != package
15                and package in met
16                and is_node_in_guarded_import_block(import_node) is False
17            ):
18                self.add_message("ungrouped-imports", node=import_node, args=package)
19            current_package = package
20            if not self.linter.is_message_enabled(
21                "ungrouped-imports", import_node.fromlineno
22            ):
23                continue
24            met.add(package)
25
26        self._imports_stack = []
27        self._first_non_import_node = None

Path 7: 4 calls (0.0)

Module (4) 

1def leave_module(self, node: nodes.Module) -> None:
2        # Check imports are grouped by category (standard, 3rd party, local)
3        std_imports, ext_imports, loc_imports = self._check_imports_order(node)
4
5        # Check that imports are grouped by package within a given category
6        met_import: set[str] = set()  # set for 'import x' style
7        met_from: set[str] = set()  # set for 'from x import y' style
8        current_package = None
9        for import_node, import_name in std_imports + ext_imports + loc_imports:
10            met = met_from if isinstance(import_node, nodes.ImportFrom) else met_import
11            package, _, _ = import_name.partition(".")
12            if (
13                current_package
14                and current_package != package
15                and package in met
16                and is_node_in_guarded_import_block(import_node) is False
17            ):
18                self.add_message("ungrouped-imports", node=import_node, args=package)
19            current_package = package
20            if not self.linter.is_message_enabled(
21                "ungrouped-imports", import_node.fromlineno
22            ):
23                continue
24            met.add(package)
25
26        self._imports_stack = []
27        self._first_non_import_node = None

Path 8: 3 calls (0.0)

Module (3) 

1def leave_module(self, node: nodes.Module) -> None:
2        # Check imports are grouped by category (standard, 3rd party, local)
3        std_imports, ext_imports, loc_imports = self._check_imports_order(node)
4
5        # Check that imports are grouped by package within a given category
6        met_import: set[str] = set()  # set for 'import x' style
7        met_from: set[str] = set()  # set for 'from x import y' style
8        current_package = None
9        for import_node, import_name in std_imports + ext_imports + loc_imports:
10            met = met_from if isinstance(import_node, nodes.ImportFrom) else met_import
11            package, _, _ = import_name.partition(".")
12            if (
13                current_package
14                and current_package != package
15                and package in met
16                and is_node_in_guarded_import_block(import_node) is False
17            ):
18                self.add_message("ungrouped-imports", node=import_node, args=package)
19            current_package = package
20            if not self.linter.is_message_enabled(
21                "ungrouped-imports", import_node.fromlineno
22            ):
23                continue
24            met.add(package)
25
26        self._imports_stack = []
27        self._first_non_import_node = None

Path 9: 2 calls (0.0)

Module (2) 

1def leave_module(self, node: nodes.Module) -> None:
2        # Check imports are grouped by category (standard, 3rd party, local)
3        std_imports, ext_imports, loc_imports = self._check_imports_order(node)
4
5        # Check that imports are grouped by package within a given category
6        met_import: set[str] = set()  # set for 'import x' style
7        met_from: set[str] = set()  # set for 'from x import y' style
8        current_package = None
9        for import_node, import_name in std_imports + ext_imports + loc_imports:
10            met = met_from if isinstance(import_node, nodes.ImportFrom) else met_import
11            package, _, _ = import_name.partition(".")
12            if (
13                current_package
14                and current_package != package
15                and package in met
16                and is_node_in_guarded_import_block(import_node) is False
17            ):
18                self.add_message("ungrouped-imports", node=import_node, args=package)
19            current_package = package
20            if not self.linter.is_message_enabled(
21                "ungrouped-imports", import_node.fromlineno
22            ):
23                continue
24            met.add(package)
25
26        self._imports_stack = []
27        self._first_non_import_node = None

Path 10: 1 calls (0.0)

Module (1) 

1def leave_module(self, node: nodes.Module) -> None:
2        # Check imports are grouped by category (standard, 3rd party, local)
3        std_imports, ext_imports, loc_imports = self._check_imports_order(node)
4
5        # Check that imports are grouped by package within a given category
6        met_import: set[str] = set()  # set for 'import x' style
7        met_from: set[str] = set()  # set for 'from x import y' style
8        current_package = None
9        for import_node, import_name in std_imports + ext_imports + loc_imports:
10            met = met_from if isinstance(import_node, nodes.ImportFrom) else met_import
11            package, _, _ = import_name.partition(".")
12            if (
13                current_package
14                and current_package != package
15                and package in met
16                and is_node_in_guarded_import_block(import_node) is False
17            ):
18                self.add_message("ungrouped-imports", node=import_node, args=package)
19            current_package = package
20            if not self.linter.is_message_enabled(
21                "ungrouped-imports", import_node.fromlineno
22            ):
23                continue
24            met.add(package)
25
26        self._imports_stack = []
27        self._first_non_import_node = None