Path 1: 989 calls (0.77)

→ importnode ImportFrom (521) Import (468)

→ modname 'typing' (153) 'os' (86) 'collections' (63) 'sys' (56) '__future__' (52) 'abc' (37) 're' (32) '' (29) 'dataclasses' (29) 'enum' (23)

↩ return Module (989)

2 run 22 not run

1def _get_imported_module(
2        self, importnode: ImportNode, modname: str | None
3    ) -> nodes.Module | None:
4        try:
5            return importnode.do_import_module(modname)
6        except astroid.TooManyLevelsError:
7            if _ignore_import_failure(importnode, modname, self._ignored_modules):
8                return None
9            self.add_message("relative-beyond-top-level", node=importnode)
10        except astroid.AstroidSyntaxError as exc:
11            message = f"Cannot import {modname!r} due to '{exc.error}'"
12            self.add_message(
13                "syntax-error", line=importnode.lineno, args=message, confidence=HIGH
14            )
15
16        except astroid.AstroidBuildingError:
17            if not self.linter.is_message_enabled("import-error"):
18                return None
19            if _ignore_import_failure(importnode, modname, self._ignored_modules):
20                return None
21            if (
22                not self.linter.config.analyse_fallback_blocks
23                and is_from_fallback_block(importnode)
24            ):
25                return None
26
27            dotted_modname = get_import_name(importnode, modname)
28            self.add_message("import-error", args=repr(dotted_modname), node=importnode)
29        except Exception as e:  # pragma: no cover
30            raise astroid.AstroidError from e
31        return None
            

Path 2: 237 calls (0.19)

→ importnode Import (121) ImportFrom (116)

→ modname 'nonexistent' (21) 'missing' (19) 'six' (18) 'unknown' (15) 'foo' (6) 'classes' (5) 'foo.bar' (5) 'numpy' (5) 'UNINFERABLE' (4) 'y' (4)

↩ return None (237)

⚠ exception AstroidImportError (237)

13 run 11 not run

1def _get_imported_module(
2        self, importnode: ImportNode, modname: str | None
3    ) -> nodes.Module | None:
4        try:
5            return importnode.do_import_module(modname)
6        except astroid.TooManyLevelsError:
7            if _ignore_import_failure(importnode, modname, self._ignored_modules):
8                return None
9            self.add_message("relative-beyond-top-level", node=importnode)
10        except astroid.AstroidSyntaxError as exc:
11            message = f"Cannot import {modname!r} due to '{exc.error}'"
12            self.add_message(
13                "syntax-error", line=importnode.lineno, args=message, confidence=HIGH
14            )
15
16        except astroid.AstroidBuildingError:
17            if not self.linter.is_message_enabled("import-error"):
18                return None
19            if _ignore_import_failure(importnode, modname, self._ignored_modules):
20                return None
21            if (
22                not self.linter.config.analyse_fallback_blocks
23                and is_from_fallback_block(importnode)
24            ):
25                return None
26
27            dotted_modname = get_import_name(importnode, modname)
28            self.add_message("import-error", args=repr(dotted_modname), node=importnode)
29        except Exception as e:  # pragma: no cover
30            raise astroid.AstroidError from e
31        return None
            

Path 3: 40 calls (0.03)

→ importnode Import (31) ImportFrom (9)

→ modname 'foo2' (6) 'stub_import' (4) 'some_module' (3) '_types' (2) 'urllib2' (2) 'collections.missing' (2) 'some_module_alt' (2) 'external_module' (2) 'foo' ...

↩ return None (40)

⚠ exception AstroidImportError (40)

8 run 16 not run

1def _get_imported_module(
2        self, importnode: ImportNode, modname: str | None
3    ) -> nodes.Module | None:
4        try:
5            return importnode.do_import_module(modname)
6        except astroid.TooManyLevelsError:
7            if _ignore_import_failure(importnode, modname, self._ignored_modules):
8                return None
9            self.add_message("relative-beyond-top-level", node=importnode)
10        except astroid.AstroidSyntaxError as exc:
11            message = f"Cannot import {modname!r} due to '{exc.error}'"
12            self.add_message(
13                "syntax-error", line=importnode.lineno, args=message, confidence=HIGH
14            )
15
16        except astroid.AstroidBuildingError:
17            if not self.linter.is_message_enabled("import-error"):
18                return None
19            if _ignore_import_failure(importnode, modname, self._ignored_modules):
20                return None
21            if (
22                not self.linter.config.analyse_fallback_blocks
23                and is_from_fallback_block(importnode)
24            ):
25                return None
26
27            dotted_modname = get_import_name(importnode, modname)
28            self.add_message("import-error", args=repr(dotted_modname), node=importnode)
29        except Exception as e:  # pragma: no cover
30            raise astroid.AstroidError from e
31        return None
            

Path 4: 4 calls (0.0)

→ importnode ImportFrom (3) Import (1)

→ modname 'deprecated' (2) 'lower_level.helper_function' (2)

↩ return None (4)

⚠ exception AstroidImportError (4)

7 run 17 not run

1def _get_imported_module(
2        self, importnode: ImportNode, modname: str | None
3    ) -> nodes.Module | None:
4        try:
5            return importnode.do_import_module(modname)
6        except astroid.TooManyLevelsError:
7            if _ignore_import_failure(importnode, modname, self._ignored_modules):
8                return None
9            self.add_message("relative-beyond-top-level", node=importnode)
10        except astroid.AstroidSyntaxError as exc:
11            message = f"Cannot import {modname!r} due to '{exc.error}'"
12            self.add_message(
13                "syntax-error", line=importnode.lineno, args=message, confidence=HIGH
14            )
15
16        except astroid.AstroidBuildingError:
17            if not self.linter.is_message_enabled("import-error"):
18                return None
19            if _ignore_import_failure(importnode, modname, self._ignored_modules):
20                return None
21            if (
22                not self.linter.config.analyse_fallback_blocks
23                and is_from_fallback_block(importnode)
24            ):
25                return None
26
27            dotted_modname = get_import_name(importnode, modname)
28            self.add_message("import-error", args=repr(dotted_modname), node=importnode)
29        except Exception as e:  # pragma: no cover
30            raise astroid.AstroidError from e
31        return None
            

Path 5: 4 calls (0.0)

→ importnode ImportFrom (4)

→ modname 'other_file' (1) 'parent' (1) 'a' (1) '' (1)

↩ return None (4)

⚠ exception TooManyLevelsError (4)

6 run 18 not run

1def _get_imported_module(
2        self, importnode: ImportNode, modname: str | None
3    ) -> nodes.Module | None:
4        try:
5            return importnode.do_import_module(modname)
6        except astroid.TooManyLevelsError:
7            if _ignore_import_failure(importnode, modname, self._ignored_modules):
8                return None
9            self.add_message("relative-beyond-top-level", node=importnode)
10        except astroid.AstroidSyntaxError as exc:
11            message = f"Cannot import {modname!r} due to '{exc.error}'"
12            self.add_message(
13                "syntax-error", line=importnode.lineno, args=message, confidence=HIGH
14            )
15
16        except astroid.AstroidBuildingError:
17            if not self.linter.is_message_enabled("import-error"):
18                return None
19            if _ignore_import_failure(importnode, modname, self._ignored_modules):
20                return None
21            if (
22                not self.linter.config.analyse_fallback_blocks
23                and is_from_fallback_block(importnode)
24            ):
25                return None
26
27            dotted_modname = get_import_name(importnode, modname)
28            self.add_message("import-error", args=repr(dotted_modname), node=importnode)
29        except Exception as e:  # pragma: no cover
30            raise astroid.AstroidError from e
31        return None
            

Path 6: 4 calls (0.0)

→ importnode Import (3) ImportFrom (1)

→ modname 'maybe_missing' (1) 'collections.missing' (1) 'collections.emit1' (1) 'singledispatch' (1)

↩ return None (4)

⚠ exception AstroidImportError (4)

11 run 13 not run

1def _get_imported_module(
2        self, importnode: ImportNode, modname: str | None
3    ) -> nodes.Module | None:
4        try:
5            return importnode.do_import_module(modname)
6        except astroid.TooManyLevelsError:
7            if _ignore_import_failure(importnode, modname, self._ignored_modules):
8                return None
9            self.add_message("relative-beyond-top-level", node=importnode)
10        except astroid.AstroidSyntaxError as exc:
11            message = f"Cannot import {modname!r} due to '{exc.error}'"
12            self.add_message(
13                "syntax-error", line=importnode.lineno, args=message, confidence=HIGH
14            )
15
16        except astroid.AstroidBuildingError:
17            if not self.linter.is_message_enabled("import-error"):
18                return None
19            if _ignore_import_failure(importnode, modname, self._ignored_modules):
20                return None
21            if (
22                not self.linter.config.analyse_fallback_blocks
23                and is_from_fallback_block(importnode)
24            ):
25                return None
26
27            dotted_modname = get_import_name(importnode, modname)
28            self.add_message("import-error", args=repr(dotted_modname), node=importnode)
29        except Exception as e:  # pragma: no cover
30            raise astroid.AstroidError from e
31        return None
            

Path 7: 2 calls (0.0)

→ importnode ImportFrom (2)

→ modname 'functional.s.syntax.syntax_error' (1) '' (1)

↩ return None (2)

⚠ exception AstroidSyntaxError (2)

8 run 16 not run

1def _get_imported_module(
2        self, importnode: ImportNode, modname: str | None
3    ) -> nodes.Module | None:
4        try:
5            return importnode.do_import_module(modname)
6        except astroid.TooManyLevelsError:
7            if _ignore_import_failure(importnode, modname, self._ignored_modules):
8                return None
9            self.add_message("relative-beyond-top-level", node=importnode)
10        except astroid.AstroidSyntaxError as exc:
11            message = f"Cannot import {modname!r} due to '{exc.error}'"
12            self.add_message(
13                "syntax-error", line=importnode.lineno, args=message, confidence=HIGH
14            )
15
16        except astroid.AstroidBuildingError:
17            if not self.linter.is_message_enabled("import-error"):
18                return None
19            if _ignore_import_failure(importnode, modname, self._ignored_modules):
20                return None
21            if (
22                not self.linter.config.analyse_fallback_blocks
23                and is_from_fallback_block(importnode)
24            ):
25                return None
26
27            dotted_modname = get_import_name(importnode, modname)
28            self.add_message("import-error", args=repr(dotted_modname), node=importnode)
29        except Exception as e:  # pragma: no cover
30            raise astroid.AstroidError from e
31        return None
            

Path 8: 1 calls (0.0)

→ importnode ImportFrom (1)

→ modname '' (1)

↩ return None (1)

⚠ exception TooManyLevelsError (1)

5 run 19 not run

1def _get_imported_module(
2        self, importnode: ImportNode, modname: str | None
3    ) -> nodes.Module | None:
4        try:
5            return importnode.do_import_module(modname)
6        except astroid.TooManyLevelsError:
7            if _ignore_import_failure(importnode, modname, self._ignored_modules):
8                return None
9            self.add_message("relative-beyond-top-level", node=importnode)
10        except astroid.AstroidSyntaxError as exc:
11            message = f"Cannot import {modname!r} due to '{exc.error}'"
12            self.add_message(
13                "syntax-error", line=importnode.lineno, args=message, confidence=HIGH
14            )
15
16        except astroid.AstroidBuildingError:
17            if not self.linter.is_message_enabled("import-error"):
18                return None
19            if _ignore_import_failure(importnode, modname, self._ignored_modules):
20                return None
21            if (
22                not self.linter.config.analyse_fallback_blocks
23                and is_from_fallback_block(importnode)
24            ):
25                return None
26
27            dotted_modname = get_import_name(importnode, modname)
28            self.add_message("import-error", args=repr(dotted_modname), node=importnode)
29        except Exception as e:  # pragma: no cover
30            raise astroid.AstroidError from e
31        return None