Path 1: 305 calls (0.2)

→ node ImportFrom (229) Import (76)

→ context Module (300) FunctionDef (5)

→ name 'Union' (10) 'TypedDict' (9) 'sys' (8) 'List' (8) 'Optional' (8) 'Callable' (7) 'Dict' (7) 'TYPE_CHECKING' (6) 'NoReturn' (6) 'os' (6)

→ base 'typing' (88) None (76) 'pylint' (13) 'unittest.mock' (11) 'collections' (9) 'classes' (6) 'collections.abc' (6) 'dataclasses' (5) 'sys' (5) '' (4)

→ level None (297) 1 (8)

→ alias None (289) 'Reporter' (3) 'foobar' (2) 'libalgos' (2) 't' (2) 'foo' (1) 'bar2' (1) '_re' (1) 'second' (1) 'test2' (1)

↩ return (None, None) (305)

25 run 16 not run

1def _get_first_import(
2    node: ImportNode,
3    context: nodes.LocalsDictNodeNG,
4    name: str,
5    base: str | None,
6    level: int | None,
7    alias: str | None,
8) -> tuple[nodes.Import | nodes.ImportFrom | None, str | None]:
9    """Return the node where [base.]<name> is imported or None if not found."""
10    fullname = f"{base}.{name}" if base else name
11
12    first = None
13    found = False
14    msg = "reimported"
15
16    for first in context.body:
17        if first is node:
18            continue
19        if first.scope() is node.scope() and first.fromlineno > node.fromlineno:
20            continue
21        if isinstance(first, nodes.Import):
22            if any(fullname == iname[0] for iname in first.names):
23                found = True
24                break
25            for imported_name, imported_alias in first.names:
26                if not imported_alias and imported_name == alias:
27                    found = True
28                    msg = "shadowed-import"
29                    break
30            if found:
31                break
32        elif isinstance(first, nodes.ImportFrom):
33            if level == first.level:
34                for imported_name, imported_alias in first.names:
35                    if fullname == f"{first.modname}.{imported_name}":
36                        found = True
37                        break
38                    if (
39                        name != "*"
40                        and name == imported_name
41                        and not (alias or imported_alias)
42                    ):
43                        found = True
44                        break
45                    if not imported_alias and imported_name == alias:
46                        found = True
47                        msg = "shadowed-import"
48                        break
49                if found:
50                    break
51    if found and not astroid.are_exclusive(first, node):
52        return first, msg
53    return None, None
            

Path 2: 248 calls (0.16)

→ node ImportFrom (149) Import (99)

→ context Module (242) FunctionDef (6)

→ name 'annotations' (19) 'typing' (11) 'collections' (11) 'six' (10) 'abc' (9) 'sys' (8) 'abstractmethod' (8) 'Enum' (7) 'ABCMeta' (7) 'dataclasses' (5)

→ base None (99) 'typing' (32) '__future__' (24) 'abc' (17) 'enum' (12) 'collections' (8) 'unknown' (7) 'dataclasses' (7) 'UNINFERABLE' (5) 'os' (4)

→ level None (244) 1 (4)

→ alias None (242) 'renamed_logging' (1) 'PyEnum' (1) 'np' (1) 'plt' (1) 'nonseq_func' (1) 'PATH' (1)

↩ return (None, None) (248)

13 run 28 not run

1def _get_first_import(
2    node: ImportNode,
3    context: nodes.LocalsDictNodeNG,
4    name: str,
5    base: str | None,
6    level: int | None,
7    alias: str | None,
8) -> tuple[nodes.Import | nodes.ImportFrom | None, str | None]:
9    """Return the node where [base.]<name> is imported or None if not found."""
10    fullname = f"{base}.{name}" if base else name
11
12    first = None
13    found = False
14    msg = "reimported"
15
16    for first in context.body:
17        if first is node:
18            continue
19        if first.scope() is node.scope() and first.fromlineno > node.fromlineno:
20            continue
21        if isinstance(first, nodes.Import):
22            if any(fullname == iname[0] for iname in first.names):
23                found = True
24                break
25            for imported_name, imported_alias in first.names:
26                if not imported_alias and imported_name == alias:
27                    found = True
28                    msg = "shadowed-import"
29                    break
30            if found:
31                break
32        elif isinstance(first, nodes.ImportFrom):
33            if level == first.level:
34                for imported_name, imported_alias in first.names:
35                    if fullname == f"{first.modname}.{imported_name}":
36                        found = True
37                        break
38                    if (
39                        name != "*"
40                        and name == imported_name
41                        and not (alias or imported_alias)
42                    ):
43                        found = True
44                        break
45                    if not imported_alias and imported_name == alias:
46                        found = True
47                        msg = "shadowed-import"
48                        break
49                if found:
50                    break
51    if found and not astroid.are_exclusive(first, node):
52        return first, msg
53    return None, None
            

Path 3: 156 calls (0.1)

→ node ImportFrom (79) Import (77)

→ context Module (110) FunctionDef (46)

→ name 'print_function' (13) 'error' (10) 'logging' (10) 're' (9) 'os' (7) 'argparse' (6) 'collections' (5) 'sys' (5) 'TypeVar' (5) 'THING1' (4)

→ base None (77) '__future__' (17) 'typing' (10) 're' (9) '' (4) 'thing1' (2) 'all_the_things' (2) 'sys' (2) 'os.path' (2) 'optparse' (2)

→ level None (144) 1 (11) 3 (1)

→ alias None (148) 'renamed_logging' (2) 'łos' (2) 'OrderedDict' (1) 'blogging' (1) 'ass' (1) 'abc' (1)

↩ return (None, None) (156)

11 run 30 not run

1def _get_first_import(
2    node: ImportNode,
3    context: nodes.LocalsDictNodeNG,
4    name: str,
5    base: str | None,
6    level: int | None,
7    alias: str | None,
8) -> tuple[nodes.Import | nodes.ImportFrom | None, str | None]:
9    """Return the node where [base.]<name> is imported or None if not found."""
10    fullname = f"{base}.{name}" if base else name
11
12    first = None
13    found = False
14    msg = "reimported"
15
16    for first in context.body:
17        if first is node:
18            continue
19        if first.scope() is node.scope() and first.fromlineno > node.fromlineno:
20            continue
21        if isinstance(first, nodes.Import):
22            if any(fullname == iname[0] for iname in first.names):
23                found = True
24                break
25            for imported_name, imported_alias in first.names:
26                if not imported_alias and imported_name == alias:
27                    found = True
28                    msg = "shadowed-import"
29                    break
30            if found:
31                break
32        elif isinstance(first, nodes.ImportFrom):
33            if level == first.level:
34                for imported_name, imported_alias in first.names:
35                    if fullname == f"{first.modname}.{imported_name}":
36                        found = True
37                        break
38                    if (
39                        name != "*"
40                        and name == imported_name
41                        and not (alias or imported_alias)
42                    ):
43                        found = True
44                        break
45                    if not imported_alias and imported_name == alias:
46                        found = True
47                        msg = "shadowed-import"
48                        break
49                if found:
50                    break
51    if found and not astroid.are_exclusive(first, node):
52        return first, msg
53    return None, None
            

Path 4: 145 calls (0.09)

→ node Import (84) ImportFrom (61)

→ context Module (139) FunctionDef (5) ClassDef (1)

→ name 'os' (24) 'nonexistent' (21) 'abc' (10) 'Enum' (6) 'Any' (4) 'sys' (4) 'asyncio' (3) 'annotations' (3) 'ABCMeta' (3) 'print_function' (2)

→ base None (84) 'typing' (16) 'enum' (7) '__future__' (6) 'functools' (6) 'data.suppliermodule_test' (6) 'abc' (5) 'collections' (3) 'UNINFERABLE' (2) 'data...

→ level None (144) 2 (1)

→ alias None (143) '__annotations__' (1) 'ExtensionProtocol' (1)

↩ return (None, None) (145)

12 run 29 not run

1def _get_first_import(
2    node: ImportNode,
3    context: nodes.LocalsDictNodeNG,
4    name: str,
5    base: str | None,
6    level: int | None,
7    alias: str | None,
8) -> tuple[nodes.Import | nodes.ImportFrom | None, str | None]:
9    """Return the node where [base.]<name> is imported or None if not found."""
10    fullname = f"{base}.{name}" if base else name
11
12    first = None
13    found = False
14    msg = "reimported"
15
16    for first in context.body:
17        if first is node:
18            continue
19        if first.scope() is node.scope() and first.fromlineno > node.fromlineno:
20            continue
21        if isinstance(first, nodes.Import):
22            if any(fullname == iname[0] for iname in first.names):
23                found = True
24                break
25            for imported_name, imported_alias in first.names:
26                if not imported_alias and imported_name == alias:
27                    found = True
28                    msg = "shadowed-import"
29                    break
30            if found:
31                break
32        elif isinstance(first, nodes.ImportFrom):
33            if level == first.level:
34                for imported_name, imported_alias in first.names:
35                    if fullname == f"{first.modname}.{imported_name}":
36                        found = True
37                        break
38                    if (
39                        name != "*"
40                        and name == imported_name
41                        and not (alias or imported_alias)
42                    ):
43                        found = True
44                        break
45                    if not imported_alias and imported_name == alias:
46                        found = True
47                        msg = "shadowed-import"
48                        break
49                if found:
50                    break
51    if found and not astroid.are_exclusive(first, node):
52        return first, msg
53    return None, None
            

Path 5: 125 calls (0.08)

→ node Import (74) ImportFrom (51)

→ context Module (123) FunctionDef (2)

→ name 'typing' (12) 'collections.abc' (4) 'sys' (4) 'six' (4) 'contextlib' (3) 'Callable' (3) 'TYPE_CHECKING' (3) 'Union' (3) 'collections' (3) 're' (3)

→ base None (74) 'typing' (19) 'dataclasses' (3) 'collections.abc' (3) 'unknown' (3) 'enum' (3) 'pathlib' (3) 'ala_bala_portocola' (2) 'concurrent.futures' (...

→ level None (125)

→ alias None (116) 'pd' (2) 'keyword_only' (1) 'logging' (1) 'ok' (1) 'foobar' (1) 'test_cp' (1) 'test' (1) 'CollectionCounter' (1)

↩ return (None, None) (125)

17 run 24 not run

1def _get_first_import(
2    node: ImportNode,
3    context: nodes.LocalsDictNodeNG,
4    name: str,
5    base: str | None,
6    level: int | None,
7    alias: str | None,
8) -> tuple[nodes.Import | nodes.ImportFrom | None, str | None]:
9    """Return the node where [base.]<name> is imported or None if not found."""
10    fullname = f"{base}.{name}" if base else name
11
12    first = None
13    found = False
14    msg = "reimported"
15
16    for first in context.body:
17        if first is node:
18            continue
19        if first.scope() is node.scope() and first.fromlineno > node.fromlineno:
20            continue
21        if isinstance(first, nodes.Import):
22            if any(fullname == iname[0] for iname in first.names):
23                found = True
24                break
25            for imported_name, imported_alias in first.names:
26                if not imported_alias and imported_name == alias:
27                    found = True
28                    msg = "shadowed-import"
29                    break
30            if found:
31                break
32        elif isinstance(first, nodes.ImportFrom):
33            if level == first.level:
34                for imported_name, imported_alias in first.names:
35                    if fullname == f"{first.modname}.{imported_name}":
36                        found = True
37                        break
38                    if (
39                        name != "*"
40                        and name == imported_name
41                        and not (alias or imported_alias)
42                    ):
43                        found = True
44                        break
45                    if not imported_alias and imported_name == alias:
46                        found = True
47                        msg = "shadowed-import"
48                        break
49                if found:
50                    break
51    if found and not astroid.are_exclusive(first, node):
52        return first, msg
53    return None, None
            

Path 6: 111 calls (0.07)

→ node ImportFrom (70) Import (41)

→ context Module (109) FunctionDef (2)

→ name 'typing' (8) 'logging' (5) 'Callable' (4) 'Union' (4) 'dataclasses' (3) 'List' (3) 'Optional' (3) 'dataclass' (3) 'Any' (3) 'os' (3)

→ base None (41) 'typing' (29) 'city' (6) 'dataclasses' (6) 'thing2' (4) 'collections' (4) 'missing' (3) 'lala' (2) 'collections.abc' (2) 'functional.u.unpac...

→ level None (107) 1 (4)

→ alias None (101) 'dc' (2) 'renamed_logging' (2) 't' (2) 'te' (2) 'path' (1) 'OS' (1)

↩ return (None, None) (111)

21 run 20 not run

1def _get_first_import(
2    node: ImportNode,
3    context: nodes.LocalsDictNodeNG,
4    name: str,
5    base: str | None,
6    level: int | None,
7    alias: str | None,
8) -> tuple[nodes.Import | nodes.ImportFrom | None, str | None]:
9    """Return the node where [base.]<name> is imported or None if not found."""
10    fullname = f"{base}.{name}" if base else name
11
12    first = None
13    found = False
14    msg = "reimported"
15
16    for first in context.body:
17        if first is node:
18            continue
19        if first.scope() is node.scope() and first.fromlineno > node.fromlineno:
20            continue
21        if isinstance(first, nodes.Import):
22            if any(fullname == iname[0] for iname in first.names):
23                found = True
24                break
25            for imported_name, imported_alias in first.names:
26                if not imported_alias and imported_name == alias:
27                    found = True
28                    msg = "shadowed-import"
29                    break
30            if found:
31                break
32        elif isinstance(first, nodes.ImportFrom):
33            if level == first.level:
34                for imported_name, imported_alias in first.names:
35                    if fullname == f"{first.modname}.{imported_name}":
36                        found = True
37                        break
38                    if (
39                        name != "*"
40                        and name == imported_name
41                        and not (alias or imported_alias)
42                    ):
43                        found = True
44                        break
45                    if not imported_alias and imported_name == alias:
46                        found = True
47                        msg = "shadowed-import"
48                        break
49                if found:
50                    break
51    if found and not astroid.are_exclusive(first, node):
52        return first, msg
53    return None, None
            

Path 7: 66 calls (0.04)

→ node Import (36) ImportFrom (30)

→ context Module (65) FunctionDef (1)

→ name 're' (10) 'error' (10) 'unknown' (2) 'urllib2' (2) 'sys' (2) 'argparse' (2) 'optparse' (2) 'get_cache_token' (2) 'exit' (1) 'LocalException' (1)

→ base None (36) 're' (9) '_abc' (8) 'urllib' (2) 'collections' (2) '_py_abc' (2) 'unknown' (1) 'sys' (1) 'neighbor_module' (1) 'urlparse' (1)

→ level None (66)

→ alias None (59) 'urllib_request' (2) 'urllib_error' (2) 'js' (2) 'pd' (1)

↩ return (None, None) (66)

11 run 30 not run

1def _get_first_import(
2    node: ImportNode,
3    context: nodes.LocalsDictNodeNG,
4    name: str,
5    base: str | None,
6    level: int | None,
7    alias: str | None,
8) -> tuple[nodes.Import | nodes.ImportFrom | None, str | None]:
9    """Return the node where [base.]<name> is imported or None if not found."""
10    fullname = f"{base}.{name}" if base else name
11
12    first = None
13    found = False
14    msg = "reimported"
15
16    for first in context.body:
17        if first is node:
18            continue
19        if first.scope() is node.scope() and first.fromlineno > node.fromlineno:
20            continue
21        if isinstance(first, nodes.Import):
22            if any(fullname == iname[0] for iname in first.names):
23                found = True
24                break
25            for imported_name, imported_alias in first.names:
26                if not imported_alias and imported_name == alias:
27                    found = True
28                    msg = "shadowed-import"
29                    break
30            if found:
31                break
32        elif isinstance(first, nodes.ImportFrom):
33            if level == first.level:
34                for imported_name, imported_alias in first.names:
35                    if fullname == f"{first.modname}.{imported_name}":
36                        found = True
37                        break
38                    if (
39                        name != "*"
40                        and name == imported_name
41                        and not (alias or imported_alias)
42                    ):
43                        found = True
44                        break
45                    if not imported_alias and imported_name == alias:
46                        found = True
47                        msg = "shadowed-import"
48                        break
49                if found:
50                    break
51    if found and not astroid.are_exclusive(first, node):
52        return first, msg
53    return None, None
            

Path 8: 58 calls (0.04)

→ node ImportFrom (34) Import (24)

→ context Module (58)

→ name 'os' (8) 'math' (4) 'random' (4) 'are_exclusive' (3) 'delete' (2) 'get' (2) 'head' (2) 'options' (2) 'patch' (2) 'post' (2)

→ base None (24) 'requests' (16) 'threading' (5) 'astroid' (4) 'typing' (3) 'importlib.machinery' (2) '__future__' (1) 'collections' (1) 'distutils.util' (1)...

→ level None (58)

→ alias None (49) 'logging' (1) 'delete_r' (1) 'get_r' (1) 'head_r' (1) 'options_r' (1) 'patch_r' (1) 'post_r' (1) 'put_r' (1) 'request_r' (1)

↩ return (None, None) (58)

16 run 25 not run

1def _get_first_import(
2    node: ImportNode,
3    context: nodes.LocalsDictNodeNG,
4    name: str,
5    base: str | None,
6    level: int | None,
7    alias: str | None,
8) -> tuple[nodes.Import | nodes.ImportFrom | None, str | None]:
9    """Return the node where [base.]<name> is imported or None if not found."""
10    fullname = f"{base}.{name}" if base else name
11
12    first = None
13    found = False
14    msg = "reimported"
15
16    for first in context.body:
17        if first is node:
18            continue
19        if first.scope() is node.scope() and first.fromlineno > node.fromlineno:
20            continue
21        if isinstance(first, nodes.Import):
22            if any(fullname == iname[0] for iname in first.names):
23                found = True
24                break
25            for imported_name, imported_alias in first.names:
26                if not imported_alias and imported_name == alias:
27                    found = True
28                    msg = "shadowed-import"
29                    break
30            if found:
31                break
32        elif isinstance(first, nodes.ImportFrom):
33            if level == first.level:
34                for imported_name, imported_alias in first.names:
35                    if fullname == f"{first.modname}.{imported_name}":
36                        found = True
37                        break
38                    if (
39                        name != "*"
40                        and name == imported_name
41                        and not (alias or imported_alias)
42                    ):
43                        found = True
44                        break
45                    if not imported_alias and imported_name == alias:
46                        found = True
47                        msg = "shadowed-import"
48                        break
49                if found:
50                    break
51    if found and not astroid.are_exclusive(first, node):
52        return first, msg
53    return None, None
            

Path 9: 34 calls (0.02)

→ node Import (25) ImportFrom (9)

→ context Module (19) FunctionDef (15)

→ name 'os' (8) 'optparse' (2) 'socket' (2) '*' (2) 'threading.current_thread' (1) 'distutils' (1) 'xml.etree.cElementTree' (1) 'imp' (1) 'generators' (1) 's...

→ base None (25) 'math' (2) 'empty' (2) '__future__' (1) 'collections' (1) 'os' (1) '' (1) 'double_name' (1)

→ level None (32) 1 (1) 3 (1)

→ alias None (25) 'os' (4) 'thyme' (1) 'rand' (1) 'sock' (1) 'sign' (1) 'cosplay' (1)

↩ return (None, None) (34)

9 run 32 not run

1def _get_first_import(
2    node: ImportNode,
3    context: nodes.LocalsDictNodeNG,
4    name: str,
5    base: str | None,
6    level: int | None,
7    alias: str | None,
8) -> tuple[nodes.Import | nodes.ImportFrom | None, str | None]:
9    """Return the node where [base.]<name> is imported or None if not found."""
10    fullname = f"{base}.{name}" if base else name
11
12    first = None
13    found = False
14    msg = "reimported"
15
16    for first in context.body:
17        if first is node:
18            continue
19        if first.scope() is node.scope() and first.fromlineno > node.fromlineno:
20            continue
21        if isinstance(first, nodes.Import):
22            if any(fullname == iname[0] for iname in first.names):
23                found = True
24                break
25            for imported_name, imported_alias in first.names:
26                if not imported_alias and imported_name == alias:
27                    found = True
28                    msg = "shadowed-import"
29                    break
30            if found:
31                break
32        elif isinstance(first, nodes.ImportFrom):
33            if level == first.level:
34                for imported_name, imported_alias in first.names:
35                    if fullname == f"{first.modname}.{imported_name}":
36                        found = True
37                        break
38                    if (
39                        name != "*"
40                        and name == imported_name
41                        and not (alias or imported_alias)
42                    ):
43                        found = True
44                        break
45                    if not imported_alias and imported_name == alias:
46                        found = True
47                        msg = "shadowed-import"
48                        break
49                if found:
50                    break
51    if found and not astroid.are_exclusive(first, node):
52        return first, msg
53    return None, None
            

Path 10: 31 calls (0.02)

→ node Import (19) ImportFrom (12)

→ context Module (31)

→ name '_TreeType' (3) 'collections.missing' (2) 'collections.emit1' (2) 'Literal' (2) 'TreeType' (1) 'something' (1) 'anything' (1) 'collections.indeed_miss...

→ base None (19) 'collections' (3) '_types' (2) 'typing' (2) 'types' (1) '' (1) 'pprint' (1) 'typing_extensions' (1) 'pylint.lint' (1)

→ level None (30) 1 (1)

→ alias None (31)

↩ return (None, None) (31)

24 run 17 not run

1def _get_first_import(
2    node: ImportNode,
3    context: nodes.LocalsDictNodeNG,
4    name: str,
5    base: str | None,
6    level: int | None,
7    alias: str | None,
8) -> tuple[nodes.Import | nodes.ImportFrom | None, str | None]:
9    """Return the node where [base.]<name> is imported or None if not found."""
10    fullname = f"{base}.{name}" if base else name
11
12    first = None
13    found = False
14    msg = "reimported"
15
16    for first in context.body:
17        if first is node:
18            continue
19        if first.scope() is node.scope() and first.fromlineno > node.fromlineno:
20            continue
21        if isinstance(first, nodes.Import):
22            if any(fullname == iname[0] for iname in first.names):
23                found = True
24                break
25            for imported_name, imported_alias in first.names:
26                if not imported_alias and imported_name == alias:
27                    found = True
28                    msg = "shadowed-import"
29                    break
30            if found:
31                break
32        elif isinstance(first, nodes.ImportFrom):
33            if level == first.level:
34                for imported_name, imported_alias in first.names:
35                    if fullname == f"{first.modname}.{imported_name}":
36                        found = True
37                        break
38                    if (
39                        name != "*"
40                        and name == imported_name
41                        and not (alias or imported_alias)
42                    ):
43                        found = True
44                        break
45                    if not imported_alias and imported_name == alias:
46                        found = True
47                        msg = "shadowed-import"
48                        break
49                if found:
50                    break
51    if found and not astroid.are_exclusive(first, node):
52        return first, msg
53    return None, None
            

Path 11: 27 calls (0.02)

→ node ImportFrom (23) Import (4)

→ context Module (27)

→ name 'Missing' (12) 'Unknown' (2) 'Dict' (1) 'NoReturn' (1) 'ClassVar' (1) 'Portocala' (1) 'ctypes' (1) 'overload' (1) 'dataclass' (1) 'ABCMeta' (1)

→ base 'missing' (12) 'typing' (4) None (4) 'unknown' (1) 'ala' (1) 'Unknown' (1) 'dataclasses' (1) 'abc' (1) 'a' (1) 'graphlib' (1)

→ level None (26) 1 (1)

→ alias None (27)

↩ return (None, None) (27)

16 run 25 not run

1def _get_first_import(
2    node: ImportNode,
3    context: nodes.LocalsDictNodeNG,
4    name: str,
5    base: str | None,
6    level: int | None,
7    alias: str | None,
8) -> tuple[nodes.Import | nodes.ImportFrom | None, str | None]:
9    """Return the node where [base.]<name> is imported or None if not found."""
10    fullname = f"{base}.{name}" if base else name
11
12    first = None
13    found = False
14    msg = "reimported"
15
16    for first in context.body:
17        if first is node:
18            continue
19        if first.scope() is node.scope() and first.fromlineno > node.fromlineno:
20            continue
21        if isinstance(first, nodes.Import):
22            if any(fullname == iname[0] for iname in first.names):
23                found = True
24                break
25            for imported_name, imported_alias in first.names:
26                if not imported_alias and imported_name == alias:
27                    found = True
28                    msg = "shadowed-import"
29                    break
30            if found:
31                break
32        elif isinstance(first, nodes.ImportFrom):
33            if level == first.level:
34                for imported_name, imported_alias in first.names:
35                    if fullname == f"{first.modname}.{imported_name}":
36                        found = True
37                        break
38                    if (
39                        name != "*"
40                        and name == imported_name
41                        and not (alias or imported_alias)
42                    ):
43                        found = True
44                        break
45                    if not imported_alias and imported_name == alias:
46                        found = True
47                        msg = "shadowed-import"
48                        break
49                if found:
50                    break
51    if found and not astroid.are_exclusive(first, node):
52        return first, msg
53    return None, None
            

Path 12: 26 calls (0.02)

→ node ImportFrom (15) Import (11)

→ context Module (26)

→ name 'w0401_cycle' (2) 'xml' (2) 'datetime' (2) 'Enum' (1) 'Decimal' (1) 'c_int' (1) 'matplotlib.pyplot' (1) 'unittest.case' (1) 'wraps' (1) 'namedtuple' (...

→ base None (11) '' (3) 'collections' (2) 'string' (2) 'sys' (2) 'enum' (1) 'decimal' (1) 'ctypes' (1) 'functools' (1) 'os' (1)

→ level None (25) 3 (1)

→ alias None (19) 'plt' (1) 'sql' (1) 'abc' (1) 'PATH' (1) 'OS' (1) 'VERSION' (1) 'RE' (1)

↩ return (None, None) (26)

19 run 22 not run

1def _get_first_import(
2    node: ImportNode,
3    context: nodes.LocalsDictNodeNG,
4    name: str,
5    base: str | None,
6    level: int | None,
7    alias: str | None,
8) -> tuple[nodes.Import | nodes.ImportFrom | None, str | None]:
9    """Return the node where [base.]<name> is imported or None if not found."""
10    fullname = f"{base}.{name}" if base else name
11
12    first = None
13    found = False
14    msg = "reimported"
15
16    for first in context.body:
17        if first is node:
18            continue
19        if first.scope() is node.scope() and first.fromlineno > node.fromlineno:
20            continue
21        if isinstance(first, nodes.Import):
22            if any(fullname == iname[0] for iname in first.names):
23                found = True
24                break
25            for imported_name, imported_alias in first.names:
26                if not imported_alias and imported_name == alias:
27                    found = True
28                    msg = "shadowed-import"
29                    break
30            if found:
31                break
32        elif isinstance(first, nodes.ImportFrom):
33            if level == first.level:
34                for imported_name, imported_alias in first.names:
35                    if fullname == f"{first.modname}.{imported_name}":
36                        found = True
37                        break
38                    if (
39                        name != "*"
40                        and name == imported_name
41                        and not (alias or imported_alias)
42                    ):
43                        found = True
44                        break
45                    if not imported_alias and imported_name == alias:
46                        found = True
47                        msg = "shadowed-import"
48                        break
49                if found:
50                    break
51    if found and not astroid.are_exclusive(first, node):
52        return first, msg
53    return None, None
            

Path 13: 20 calls (0.01)

→ node ImportFrom (18) Import (2)

→ context Module (19) FunctionDef (1)

→ name 'Protocol' (3) 'dataclass' (2) 'List' (2) 'IntEnum' (1) 'log10' (1) 'uninstalled' (1) 'overload' (1) 'Missing' (1) 'Any' (1) 'Dict' (1)

→ base 'typing' (9) None (2) 'enum' (1) 'math' (1) 'pydantic.dataclasses' (1) 'missing' (1) 'dataclasses' (1) 'collections' (1) 'another' (1) 'pylint.lint' (...

→ level None (18) 1 (2)

→ alias None (20)

↩ return (None, None) (20)

20 run 21 not run

1def _get_first_import(
2    node: ImportNode,
3    context: nodes.LocalsDictNodeNG,
4    name: str,
5    base: str | None,
6    level: int | None,
7    alias: str | None,
8) -> tuple[nodes.Import | nodes.ImportFrom | None, str | None]:
9    """Return the node where [base.]<name> is imported or None if not found."""
10    fullname = f"{base}.{name}" if base else name
11
12    first = None
13    found = False
14    msg = "reimported"
15
16    for first in context.body:
17        if first is node:
18            continue
19        if first.scope() is node.scope() and first.fromlineno > node.fromlineno:
20            continue
21        if isinstance(first, nodes.Import):
22            if any(fullname == iname[0] for iname in first.names):
23                found = True
24                break
25            for imported_name, imported_alias in first.names:
26                if not imported_alias and imported_name == alias:
27                    found = True
28                    msg = "shadowed-import"
29                    break
30            if found:
31                break
32        elif isinstance(first, nodes.ImportFrom):
33            if level == first.level:
34                for imported_name, imported_alias in first.names:
35                    if fullname == f"{first.modname}.{imported_name}":
36                        found = True
37                        break
38                    if (
39                        name != "*"
40                        and name == imported_name
41                        and not (alias or imported_alias)
42                    ):
43                        found = True
44                        break
45                    if not imported_alias and imported_name == alias:
46                        found = True
47                        msg = "shadowed-import"
48                        break
49                if found:
50                    break
51    if found and not astroid.are_exclusive(first, node):
52        return first, msg
53    return None, None
            

Path 14: 20 calls (0.01)

→ node ImportFrom (13) Import (7)

→ context Module (20)

→ name 'Protocol' (6) 'sys' (2) 'os' (2) 'deque' (2) 'socket' (1) 'defaultdict' (1) 'namedtuple' (1) 're' (1) 'List' (1) 'package4' (1)

→ base None (7) 'collections' (4) 'typing' (4) 'typing_extensions' (3) '' (1) 'random' (1)

→ level None (19) 1 (1)

→ alias None (20)

↩ return (None, None) (20)

23 run 18 not run

1def _get_first_import(
2    node: ImportNode,
3    context: nodes.LocalsDictNodeNG,
4    name: str,
5    base: str | None,
6    level: int | None,
7    alias: str | None,
8) -> tuple[nodes.Import | nodes.ImportFrom | None, str | None]:
9    """Return the node where [base.]<name> is imported or None if not found."""
10    fullname = f"{base}.{name}" if base else name
11
12    first = None
13    found = False
14    msg = "reimported"
15
16    for first in context.body:
17        if first is node:
18            continue
19        if first.scope() is node.scope() and first.fromlineno > node.fromlineno:
20            continue
21        if isinstance(first, nodes.Import):
22            if any(fullname == iname[0] for iname in first.names):
23                found = True
24                break
25            for imported_name, imported_alias in first.names:
26                if not imported_alias and imported_name == alias:
27                    found = True
28                    msg = "shadowed-import"
29                    break
30            if found:
31                break
32        elif isinstance(first, nodes.ImportFrom):
33            if level == first.level:
34                for imported_name, imported_alias in first.names:
35                    if fullname == f"{first.modname}.{imported_name}":
36                        found = True
37                        break
38                    if (
39                        name != "*"
40                        and name == imported_name
41                        and not (alias or imported_alias)
42                    ):
43                        found = True
44                        break
45                    if not imported_alias and imported_name == alias:
46                        found = True
47                        msg = "shadowed-import"
48                        break
49                if found:
50                    break
51    if found and not astroid.are_exclusive(first, node):
52        return first, msg
53    return None, None
            

Path 15: 19 calls (0.01)

→ node Import (16) ImportFrom (3)

→ context Module (19)

→ name 'os' (2) 'ast' (1) 'symtable' (1) 'sys' (1) 'time' (1) 'random' (1) 'socket' (1) 'tokenize' (1) 'trace' (1) 'tabnanny' (1)

→ base None (16) 'math' (2) 'collections' (1)

→ level None (19)

→ alias None (13) 'thyme' (1) 'rand' (1) 'sock' (1) 'sign' (1) 'cosplay' (1) 'configparser' (1)

↩ return (None, None) (19)

15 run 26 not run

1def _get_first_import(
2    node: ImportNode,
3    context: nodes.LocalsDictNodeNG,
4    name: str,
5    base: str | None,
6    level: int | None,
7    alias: str | None,
8) -> tuple[nodes.Import | nodes.ImportFrom | None, str | None]:
9    """Return the node where [base.]<name> is imported or None if not found."""
10    fullname = f"{base}.{name}" if base else name
11
12    first = None
13    found = False
14    msg = "reimported"
15
16    for first in context.body:
17        if first is node:
18            continue
19        if first.scope() is node.scope() and first.fromlineno > node.fromlineno:
20            continue
21        if isinstance(first, nodes.Import):
22            if any(fullname == iname[0] for iname in first.names):
23                found = True
24                break
25            for imported_name, imported_alias in first.names:
26                if not imported_alias and imported_name == alias:
27                    found = True
28                    msg = "shadowed-import"
29                    break
30            if found:
31                break
32        elif isinstance(first, nodes.ImportFrom):
33            if level == first.level:
34                for imported_name, imported_alias in first.names:
35                    if fullname == f"{first.modname}.{imported_name}":
36                        found = True
37                        break
38                    if (
39                        name != "*"
40                        and name == imported_name
41                        and not (alias or imported_alias)
42                    ):
43                        found = True
44                        break
45                    if not imported_alias and imported_name == alias:
46                        found = True
47                        msg = "shadowed-import"
48                        break
49                if found:
50                    break
51    if found and not astroid.are_exclusive(first, node):
52        return first, msg
53    return None, None
            

Path 16: 16 calls (0.01)

→ node ImportFrom (13) Import (3)

→ context Module (15) FunctionDef (1)

→ name 'logging.handlers' (1) 'foo' (1) 'Unknown' (1) 'Enum' (1) 'Any' (1) 'Dict' (1) 'BaseModel' (1) 'nope' (1) 'get_module_part' (1) 'is_standard_module' (...

→ base None (3) 'typing' (3) 'astroid.modutils' (2) 'first_party.bar' (1) 'unknown' (1) 'enum' (1) 'pydantic' (1) 'distutils.doesnottexists' (1) 'xyz' (1) 'm...

→ level None (15) 1 (1)

→ alias None (15) 'RE' (1)

↩ return (None, None) (16)

24 run 17 not run

1def _get_first_import(
2    node: ImportNode,
3    context: nodes.LocalsDictNodeNG,
4    name: str,
5    base: str | None,
6    level: int | None,
7    alias: str | None,
8) -> tuple[nodes.Import | nodes.ImportFrom | None, str | None]:
9    """Return the node where [base.]<name> is imported or None if not found."""
10    fullname = f"{base}.{name}" if base else name
11
12    first = None
13    found = False
14    msg = "reimported"
15
16    for first in context.body:
17        if first is node:
18            continue
19        if first.scope() is node.scope() and first.fromlineno > node.fromlineno:
20            continue
21        if isinstance(first, nodes.Import):
22            if any(fullname == iname[0] for iname in first.names):
23                found = True
24                break
25            for imported_name, imported_alias in first.names:
26                if not imported_alias and imported_name == alias:
27                    found = True
28                    msg = "shadowed-import"
29                    break
30            if found:
31                break
32        elif isinstance(first, nodes.ImportFrom):
33            if level == first.level:
34                for imported_name, imported_alias in first.names:
35                    if fullname == f"{first.modname}.{imported_name}":
36                        found = True
37                        break
38                    if (
39                        name != "*"
40                        and name == imported_name
41                        and not (alias or imported_alias)
42                    ):
43                        found = True
44                        break
45                    if not imported_alias and imported_name == alias:
46                        found = True
47                        msg = "shadowed-import"
48                        break
49                if found:
50                    break
51    if found and not astroid.are_exclusive(first, node):
52        return first, msg
53    return None, None
            

Path 17: 12 calls (0.01)

→ node ImportFrom (12)

→ context Module (12)

→ name 'func_w0401' (5) 'w0401_cycle' (4) 'var' (2) 'data' (1)

→ base '' (10) 'b' (2)

→ level 1 (12)

→ alias None (12)

↩ return (None, None) (12)

14 run 27 not run

1def _get_first_import(
2    node: ImportNode,
3    context: nodes.LocalsDictNodeNG,
4    name: str,
5    base: str | None,
6    level: int | None,
7    alias: str | None,
8) -> tuple[nodes.Import | nodes.ImportFrom | None, str | None]:
9    """Return the node where [base.]<name> is imported or None if not found."""
10    fullname = f"{base}.{name}" if base else name
11
12    first = None
13    found = False
14    msg = "reimported"
15
16    for first in context.body:
17        if first is node:
18            continue
19        if first.scope() is node.scope() and first.fromlineno > node.fromlineno:
20            continue
21        if isinstance(first, nodes.Import):
22            if any(fullname == iname[0] for iname in first.names):
23                found = True
24                break
25            for imported_name, imported_alias in first.names:
26                if not imported_alias and imported_name == alias:
27                    found = True
28                    msg = "shadowed-import"
29                    break
30            if found:
31                break
32        elif isinstance(first, nodes.ImportFrom):
33            if level == first.level:
34                for imported_name, imported_alias in first.names:
35                    if fullname == f"{first.modname}.{imported_name}":
36                        found = True
37                        break
38                    if (
39                        name != "*"
40                        and name == imported_name
41                        and not (alias or imported_alias)
42                    ):
43                        found = True
44                        break
45                    if not imported_alias and imported_name == alias:
46                        found = True
47                        msg = "shadowed-import"
48                        break
49                if found:
50                    break
51    if found and not astroid.are_exclusive(first, node):
52        return first, msg
53    return None, None
            

Path 18: 11 calls (0.01)

→ node ImportFrom (10) Import (1)

→ context Module (11)

→ name 'singledispatch' (2) 'configparser' (2) 'datetime' (1) 'Literal' (1) 'Counter' (1) 'OrderedDict' (1) 'defaultdict' (1) 'UserDict' (1) 'GenericAlias' (...

→ base 'collections' (4) 'functools' (1) 'singledispatch' (1) 'datetime' (1) 'typing_extensions' (1) 'types' (1) 'six.moves' (1) None (1)

→ level None (11)

→ alias None (11)

↩ return (None, None) (11)

20 run 21 not run

1def _get_first_import(
2    node: ImportNode,
3    context: nodes.LocalsDictNodeNG,
4    name: str,
5    base: str | None,
6    level: int | None,
7    alias: str | None,
8) -> tuple[nodes.Import | nodes.ImportFrom | None, str | None]:
9    """Return the node where [base.]<name> is imported or None if not found."""
10    fullname = f"{base}.{name}" if base else name
11
12    first = None
13    found = False
14    msg = "reimported"
15
16    for first in context.body:
17        if first is node:
18            continue
19        if first.scope() is node.scope() and first.fromlineno > node.fromlineno:
20            continue
21        if isinstance(first, nodes.Import):
22            if any(fullname == iname[0] for iname in first.names):
23                found = True
24                break
25            for imported_name, imported_alias in first.names:
26                if not imported_alias and imported_name == alias:
27                    found = True
28                    msg = "shadowed-import"
29                    break
30            if found:
31                break
32        elif isinstance(first, nodes.ImportFrom):
33            if level == first.level:
34                for imported_name, imported_alias in first.names:
35                    if fullname == f"{first.modname}.{imported_name}":
36                        found = True
37                        break
38                    if (
39                        name != "*"
40                        and name == imported_name
41                        and not (alias or imported_alias)
42                    ):
43                        found = True
44                        break
45                    if not imported_alias and imported_name == alias:
46                        found = True
47                        msg = "shadowed-import"
48                        break
49                if found:
50                    break
51    if found and not astroid.are_exclusive(first, node):
52        return first, msg
53    return None, None
            

Path 19: 10 calls (0.01)

→ node Import (7) ImportFrom (3)

→ context Module (10)

→ name 'foobar' (2) 'sys' (2) '_chair' (1) '_stair' (1) 'os' (1) 're' (1) 'ElementTree' (1) 'typing' (1)

→ base None (7) 'foo.bar' (2) 'xml.etree' (1)

→ level None (10)

→ alias None (6) 'OS' (1) 'foobar' (1) 'foo' (1) 't' (1)

↩ return tuple (10)

⚠ exception GeneratorExit (10)

25 run 16 not run

1def _get_first_import(
2    node: ImportNode,
3    context: nodes.LocalsDictNodeNG,
4    name: str,
5    base: str | None,
6    level: int | None,
7    alias: str | None,
8) -> tuple[nodes.Import | nodes.ImportFrom | None, str | None]:
9    """Return the node where [base.]<name> is imported or None if not found."""
10    fullname = f"{base}.{name}" if base else name
11
12    first = None
13    found = False
14    msg = "reimported"
15
16    for first in context.body:
17        if first is node:
18            continue
19        if first.scope() is node.scope() and first.fromlineno > node.fromlineno:
20            continue
21        if isinstance(first, nodes.Import):
22            if any(fullname == iname[0] for iname in first.names):
23                found = True
24                break
25            for imported_name, imported_alias in first.names:
26                if not imported_alias and imported_name == alias:
27                    found = True
28                    msg = "shadowed-import"
29                    break
30            if found:
31                break
32        elif isinstance(first, nodes.ImportFrom):
33            if level == first.level:
34                for imported_name, imported_alias in first.names:
35                    if fullname == f"{first.modname}.{imported_name}":
36                        found = True
37                        break
38                    if (
39                        name != "*"
40                        and name == imported_name
41                        and not (alias or imported_alias)
42                    ):
43                        found = True
44                        break
45                    if not imported_alias and imported_name == alias:
46                        found = True
47                        msg = "shadowed-import"
48                        break
49                if found:
50                    break
51    if found and not astroid.are_exclusive(first, node):
52        return first, msg
53    return None, None
            

Path 20: 10 calls (0.01)

→ node Import (7) ImportFrom (3)

→ context Module (9) FunctionDef (1)

→ name 'argv' (2) 'collections' (1) 'time' (1) 'executable' (1) 're' (1) '__builtin__' (1) 'builtins' (1) 'os' (1) 'x' (1)

→ base None (7) 'sys' (3)

→ level None (10)

→ alias None (8) 'python' (1) 'builtins' (1)

↩ return (None, None) (10)

12 run 29 not run

1def _get_first_import(
2    node: ImportNode,
3    context: nodes.LocalsDictNodeNG,
4    name: str,
5    base: str | None,
6    level: int | None,
7    alias: str | None,
8) -> tuple[nodes.Import | nodes.ImportFrom | None, str | None]:
9    """Return the node where [base.]<name> is imported or None if not found."""
10    fullname = f"{base}.{name}" if base else name
11
12    first = None
13    found = False
14    msg = "reimported"
15
16    for first in context.body:
17        if first is node:
18            continue
19        if first.scope() is node.scope() and first.fromlineno > node.fromlineno:
20            continue
21        if isinstance(first, nodes.Import):
22            if any(fullname == iname[0] for iname in first.names):
23                found = True
24                break
25            for imported_name, imported_alias in first.names:
26                if not imported_alias and imported_name == alias:
27                    found = True
28                    msg = "shadowed-import"
29                    break
30            if found:
31                break
32        elif isinstance(first, nodes.ImportFrom):
33            if level == first.level:
34                for imported_name, imported_alias in first.names:
35                    if fullname == f"{first.modname}.{imported_name}":
36                        found = True
37                        break
38                    if (
39                        name != "*"
40                        and name == imported_name
41                        and not (alias or imported_alias)
42                    ):
43                        found = True
44                        break
45                    if not imported_alias and imported_name == alias:
46                        found = True
47                        msg = "shadowed-import"
48                        break
49                if found:
50                    break
51    if found and not astroid.are_exclusive(first, node):
52        return first, msg
53    return None, None
            

Path 21: 8 calls (0.01)

→ node ImportFrom (8)

→ context Module (8)

→ name '_private' (2) 'bar' (2) 'NoSelfArgument' (1) 'Class' (1) 'Class3' (1) 'my_package' (1)

→ base '' (3) 'parent' (1) 'foo' (1) 'no_self_argument' (1) 'package' (1) 'package3' (1)

→ level 1 (5) 2 (3)

→ alias None (6) 'bar' (2)

↩ return (None, None) (8)

18 run 23 not run

1def _get_first_import(
2    node: ImportNode,
3    context: nodes.LocalsDictNodeNG,
4    name: str,
5    base: str | None,
6    level: int | None,
7    alias: str | None,
8) -> tuple[nodes.Import | nodes.ImportFrom | None, str | None]:
9    """Return the node where [base.]<name> is imported or None if not found."""
10    fullname = f"{base}.{name}" if base else name
11
12    first = None
13    found = False
14    msg = "reimported"
15
16    for first in context.body:
17        if first is node:
18            continue
19        if first.scope() is node.scope() and first.fromlineno > node.fromlineno:
20            continue
21        if isinstance(first, nodes.Import):
22            if any(fullname == iname[0] for iname in first.names):
23                found = True
24                break
25            for imported_name, imported_alias in first.names:
26                if not imported_alias and imported_name == alias:
27                    found = True
28                    msg = "shadowed-import"
29                    break
30            if found:
31                break
32        elif isinstance(first, nodes.ImportFrom):
33            if level == first.level:
34                for imported_name, imported_alias in first.names:
35                    if fullname == f"{first.modname}.{imported_name}":
36                        found = True
37                        break
38                    if (
39                        name != "*"
40                        and name == imported_name
41                        and not (alias or imported_alias)
42                    ):
43                        found = True
44                        break
45                    if not imported_alias and imported_name == alias:
46                        found = True
47                        msg = "shadowed-import"
48                        break
49                if found:
50                    break
51    if found and not astroid.are_exclusive(first, node):
52        return first, msg
53    return None, None
            

Path 22: 7 calls (0.0)

→ node Import (7)

→ context Module (7)

→ name 'functools' (2) 'os' (2) 'copy' (2) 'typing' (1)

→ base None (7)

→ level None (7)

→ alias None (3) 'aliased_functools' (2) 'ass' (1) 'mytyping' (1)

↩ return tuple (7)

⚠ exception GeneratorExit (7)

13 run 28 not run

1def _get_first_import(
2    node: ImportNode,
3    context: nodes.LocalsDictNodeNG,
4    name: str,
5    base: str | None,
6    level: int | None,
7    alias: str | None,
8) -> tuple[nodes.Import | nodes.ImportFrom | None, str | None]:
9    """Return the node where [base.]<name> is imported or None if not found."""
10    fullname = f"{base}.{name}" if base else name
11
12    first = None
13    found = False
14    msg = "reimported"
15
16    for first in context.body:
17        if first is node:
18            continue
19        if first.scope() is node.scope() and first.fromlineno > node.fromlineno:
20            continue
21        if isinstance(first, nodes.Import):
22            if any(fullname == iname[0] for iname in first.names):
23                found = True
24                break
25            for imported_name, imported_alias in first.names:
26                if not imported_alias and imported_name == alias:
27                    found = True
28                    msg = "shadowed-import"
29                    break
30            if found:
31                break
32        elif isinstance(first, nodes.ImportFrom):
33            if level == first.level:
34                for imported_name, imported_alias in first.names:
35                    if fullname == f"{first.modname}.{imported_name}":
36                        found = True
37                        break
38                    if (
39                        name != "*"
40                        and name == imported_name
41                        and not (alias or imported_alias)
42                    ):
43                        found = True
44                        break
45                    if not imported_alias and imported_name == alias:
46                        found = True
47                        msg = "shadowed-import"
48                        break
49                if found:
50                    break
51    if found and not astroid.are_exclusive(first, node):
52        return first, msg
53    return None, None
            

Path 23: 6 calls (0.0)

→ node ImportFrom (4) Import (2)

→ context Module (6)

→ name '_house' (2) 'a' (1) '_b' (1) 'c' (1) '_d' (1)

→ base '_city' (4) None (2)

→ level None (6)

→ alias None (6)

↩ return tuple (6)

23 run 18 not run

1def _get_first_import(
2    node: ImportNode,
3    context: nodes.LocalsDictNodeNG,
4    name: str,
5    base: str | None,
6    level: int | None,
7    alias: str | None,
8) -> tuple[nodes.Import | nodes.ImportFrom | None, str | None]:
9    """Return the node where [base.]<name> is imported or None if not found."""
10    fullname = f"{base}.{name}" if base else name
11
12    first = None
13    found = False
14    msg = "reimported"
15
16    for first in context.body:
17        if first is node:
18            continue
19        if first.scope() is node.scope() and first.fromlineno > node.fromlineno:
20            continue
21        if isinstance(first, nodes.Import):
22            if any(fullname == iname[0] for iname in first.names):
23                found = True
24                break
25            for imported_name, imported_alias in first.names:
26                if not imported_alias and imported_name == alias:
27                    found = True
28                    msg = "shadowed-import"
29                    break
30            if found:
31                break
32        elif isinstance(first, nodes.ImportFrom):
33            if level == first.level:
34                for imported_name, imported_alias in first.names:
35                    if fullname == f"{first.modname}.{imported_name}":
36                        found = True
37                        break
38                    if (
39                        name != "*"
40                        and name == imported_name
41                        and not (alias or imported_alias)
42                    ):
43                        found = True
44                        break
45                    if not imported_alias and imported_name == alias:
46                        found = True
47                        msg = "shadowed-import"
48                        break
49                if found:
50                    break
51    if found and not astroid.are_exclusive(first, node):
52        return first, msg
53    return None, None
            

Path 24: 6 calls (0.0)

→ node Import (5) ImportFrom (1)

→ context Module (5) FunctionDef (1)

→ name 'sys' (4) 'search' (1) 'xml' (1)

→ base None (5) 're' (1)

→ level None (6)

→ alias None (5) 'sql' (1)

↩ return (None, None) (6)

15 run 26 not run

1def _get_first_import(
2    node: ImportNode,
3    context: nodes.LocalsDictNodeNG,
4    name: str,
5    base: str | None,
6    level: int | None,
7    alias: str | None,
8) -> tuple[nodes.Import | nodes.ImportFrom | None, str | None]:
9    """Return the node where [base.]<name> is imported or None if not found."""
10    fullname = f"{base}.{name}" if base else name
11
12    first = None
13    found = False
14    msg = "reimported"
15
16    for first in context.body:
17        if first is node:
18            continue
19        if first.scope() is node.scope() and first.fromlineno > node.fromlineno:
20            continue
21        if isinstance(first, nodes.Import):
22            if any(fullname == iname[0] for iname in first.names):
23                found = True
24                break
25            for imported_name, imported_alias in first.names:
26                if not imported_alias and imported_name == alias:
27                    found = True
28                    msg = "shadowed-import"
29                    break
30            if found:
31                break
32        elif isinstance(first, nodes.ImportFrom):
33            if level == first.level:
34                for imported_name, imported_alias in first.names:
35                    if fullname == f"{first.modname}.{imported_name}":
36                        found = True
37                        break
38                    if (
39                        name != "*"
40                        and name == imported_name
41                        and not (alias or imported_alias)
42                    ):
43                        found = True
44                        break
45                    if not imported_alias and imported_name == alias:
46                        found = True
47                        msg = "shadowed-import"
48                        break
49                if found:
50                    break
51    if found and not astroid.are_exclusive(first, node):
52        return first, msg
53    return None, None
            

Path 25: 6 calls (0.0)

→ node ImportFrom (4) Import (2)

→ context Module (6)

→ name 'NoReturn' (2) 'are_exclusive' (1) 'sys' (1) 'OrderedDict' (1) 'ast' (1)

→ base None (2) 'typing' (1) 'typing_extensions' (1) 'astroid' (1) 'collections' (1)

→ level None (6)

→ alias None (6)

↩ return (None, None) (6)

16 run 25 not run

1def _get_first_import(
2    node: ImportNode,
3    context: nodes.LocalsDictNodeNG,
4    name: str,
5    base: str | None,
6    level: int | None,
7    alias: str | None,
8) -> tuple[nodes.Import | nodes.ImportFrom | None, str | None]:
9    """Return the node where [base.]<name> is imported or None if not found."""
10    fullname = f"{base}.{name}" if base else name
11
12    first = None
13    found = False
14    msg = "reimported"
15
16    for first in context.body:
17        if first is node:
18            continue
19        if first.scope() is node.scope() and first.fromlineno > node.fromlineno:
20            continue
21        if isinstance(first, nodes.Import):
22            if any(fullname == iname[0] for iname in first.names):
23                found = True
24                break
25            for imported_name, imported_alias in first.names:
26                if not imported_alias and imported_name == alias:
27                    found = True
28                    msg = "shadowed-import"
29                    break
30            if found:
31                break
32        elif isinstance(first, nodes.ImportFrom):
33            if level == first.level:
34                for imported_name, imported_alias in first.names:
35                    if fullname == f"{first.modname}.{imported_name}":
36                        found = True
37                        break
38                    if (
39                        name != "*"
40                        and name == imported_name
41                        and not (alias or imported_alias)
42                    ):
43                        found = True
44                        break
45                    if not imported_alias and imported_name == alias:
46                        found = True
47                        msg = "shadowed-import"
48                        break
49                if found:
50                    break
51    if found and not astroid.are_exclusive(first, node):
52        return first, msg
53    return None, None
            

Path 26: 5 calls (0.0)

→ node ImportFrom (5)

→ context Module (5)

→ name '_private' (3) 'deque' (1) 'TYPE_CHECKING' (1)

→ base 'private_import.other_file' (1) 'astroid' (1) 'sys' (1) 'itertools' (1) 'io' (1)

→ level None (5)

→ alias None (5)

↩ return tuple (5)

27 run 14 not run

1def _get_first_import(
2    node: ImportNode,
3    context: nodes.LocalsDictNodeNG,
4    name: str,
5    base: str | None,
6    level: int | None,
7    alias: str | None,
8) -> tuple[nodes.Import | nodes.ImportFrom | None, str | None]:
9    """Return the node where [base.]<name> is imported or None if not found."""
10    fullname = f"{base}.{name}" if base else name
11
12    first = None
13    found = False
14    msg = "reimported"
15
16    for first in context.body:
17        if first is node:
18            continue
19        if first.scope() is node.scope() and first.fromlineno > node.fromlineno:
20            continue
21        if isinstance(first, nodes.Import):
22            if any(fullname == iname[0] for iname in first.names):
23                found = True
24                break
25            for imported_name, imported_alias in first.names:
26                if not imported_alias and imported_name == alias:
27                    found = True
28                    msg = "shadowed-import"
29                    break
30            if found:
31                break
32        elif isinstance(first, nodes.ImportFrom):
33            if level == first.level:
34                for imported_name, imported_alias in first.names:
35                    if fullname == f"{first.modname}.{imported_name}":
36                        found = True
37                        break
38                    if (
39                        name != "*"
40                        and name == imported_name
41                        and not (alias or imported_alias)
42                    ):
43                        found = True
44                        break
45                    if not imported_alias and imported_name == alias:
46                        found = True
47                        msg = "shadowed-import"
48                        break
49                if found:
50                    break
51    if found and not astroid.are_exclusive(first, node):
52        return first, msg
53    return None, None
            

Path 27: 5 calls (0.0)

→ node ImportFrom (5)

→ context Module (5)

→ name 'bar' (2) 'foo2' (2) 'OrderedDict' (1)

→ base '' (4) 'itertools' (1)

→ level 1 (4) None (1)

→ alias 'Bar' (1) None (1) 'foo2' (1) 'bar2' (1) 'NotOrderedDict' (1)

↩ return (None, None) (5)

26 run 15 not run

1def _get_first_import(
2    node: ImportNode,
3    context: nodes.LocalsDictNodeNG,
4    name: str,
5    base: str | None,
6    level: int | None,
7    alias: str | None,
8) -> tuple[nodes.Import | nodes.ImportFrom | None, str | None]:
9    """Return the node where [base.]<name> is imported or None if not found."""
10    fullname = f"{base}.{name}" if base else name
11
12    first = None
13    found = False
14    msg = "reimported"
15
16    for first in context.body:
17        if first is node:
18            continue
19        if first.scope() is node.scope() and first.fromlineno > node.fromlineno:
20            continue
21        if isinstance(first, nodes.Import):
22            if any(fullname == iname[0] for iname in first.names):
23                found = True
24                break
25            for imported_name, imported_alias in first.names:
26                if not imported_alias and imported_name == alias:
27                    found = True
28                    msg = "shadowed-import"
29                    break
30            if found:
31                break
32        elif isinstance(first, nodes.ImportFrom):
33            if level == first.level:
34                for imported_name, imported_alias in first.names:
35                    if fullname == f"{first.modname}.{imported_name}":
36                        found = True
37                        break
38                    if (
39                        name != "*"
40                        and name == imported_name
41                        and not (alias or imported_alias)
42                    ):
43                        found = True
44                        break
45                    if not imported_alias and imported_name == alias:
46                        found = True
47                        msg = "shadowed-import"
48                        break
49                if found:
50                    break
51    if found and not astroid.are_exclusive(first, node):
52        return first, msg
53    return None, None
            

Path 28: 4 calls (0.0)

→ node ImportFrom (3) Import (1)

→ context Module (4)

→ name 'Bar' (2) 'nonexistant' (1) 'roles' (1)

→ base 'optparse' (2) None (1) 'nodes' (1)

→ level 1 (2) 2 (1) None (1)

→ alias None (4)

↩ return (None, None) (4)

13 run 28 not run

1def _get_first_import(
2    node: ImportNode,
3    context: nodes.LocalsDictNodeNG,
4    name: str,
5    base: str | None,
6    level: int | None,
7    alias: str | None,
8) -> tuple[nodes.Import | nodes.ImportFrom | None, str | None]:
9    """Return the node where [base.]<name> is imported or None if not found."""
10    fullname = f"{base}.{name}" if base else name
11
12    first = None
13    found = False
14    msg = "reimported"
15
16    for first in context.body:
17        if first is node:
18            continue
19        if first.scope() is node.scope() and first.fromlineno > node.fromlineno:
20            continue
21        if isinstance(first, nodes.Import):
22            if any(fullname == iname[0] for iname in first.names):
23                found = True
24                break
25            for imported_name, imported_alias in first.names:
26                if not imported_alias and imported_name == alias:
27                    found = True
28                    msg = "shadowed-import"
29                    break
30            if found:
31                break
32        elif isinstance(first, nodes.ImportFrom):
33            if level == first.level:
34                for imported_name, imported_alias in first.names:
35                    if fullname == f"{first.modname}.{imported_name}":
36                        found = True
37                        break
38                    if (
39                        name != "*"
40                        and name == imported_name
41                        and not (alias or imported_alias)
42                    ):
43                        found = True
44                        break
45                    if not imported_alias and imported_name == alias:
46                        found = True
47                        msg = "shadowed-import"
48                        break
49                if found:
50                    break
51    if found and not astroid.are_exclusive(first, node):
52        return first, msg
53    return None, None
            

Path 29: 4 calls (0.0)

→ node Import (4)

→ context Module (4)

→ name 'house' (1) 'math' (1) 'os.path' (1) 'missing1' (1)

→ base None (4)

→ level None (4)

→ alias None (2) '_' (1) 'p' (1)

↩ return tuple (4)

⚠ exception GeneratorExit (4)

22 run 19 not run

1def _get_first_import(
2    node: ImportNode,
3    context: nodes.LocalsDictNodeNG,
4    name: str,
5    base: str | None,
6    level: int | None,
7    alias: str | None,
8) -> tuple[nodes.Import | nodes.ImportFrom | None, str | None]:
9    """Return the node where [base.]<name> is imported or None if not found."""
10    fullname = f"{base}.{name}" if base else name
11
12    first = None
13    found = False
14    msg = "reimported"
15
16    for first in context.body:
17        if first is node:
18            continue
19        if first.scope() is node.scope() and first.fromlineno > node.fromlineno:
20            continue
21        if isinstance(first, nodes.Import):
22            if any(fullname == iname[0] for iname in first.names):
23                found = True
24                break
25            for imported_name, imported_alias in first.names:
26                if not imported_alias and imported_name == alias:
27                    found = True
28                    msg = "shadowed-import"
29                    break
30            if found:
31                break
32        elif isinstance(first, nodes.ImportFrom):
33            if level == first.level:
34                for imported_name, imported_alias in first.names:
35                    if fullname == f"{first.modname}.{imported_name}":
36                        found = True
37                        break
38                    if (
39                        name != "*"
40                        and name == imported_name
41                        and not (alias or imported_alias)
42                    ):
43                        found = True
44                        break
45                    if not imported_alias and imported_name == alias:
46                        found = True
47                        msg = "shadowed-import"
48                        break
49                if found:
50                    break
51    if found and not astroid.are_exclusive(first, node):
52        return first, msg
53    return None, None
            

Path 30: 4 calls (0.0)

→ node ImportFrom (4)

→ context Module (4)

→ name 'lru_cache' (1) 'cache' (1) 'final' (1) 'ABCMeta' (1)

→ base 'functools' (2) 'typing' (1) 'abc' (1)

→ level None (4)

→ alias 'aliased_cache' (2) 'myfinal' (1) 'SomethingElse' (1)

↩ return tuple (4)

22 run 19 not run

1def _get_first_import(
2    node: ImportNode,
3    context: nodes.LocalsDictNodeNG,
4    name: str,
5    base: str | None,
6    level: int | None,
7    alias: str | None,
8) -> tuple[nodes.Import | nodes.ImportFrom | None, str | None]:
9    """Return the node where [base.]<name> is imported or None if not found."""
10    fullname = f"{base}.{name}" if base else name
11
12    first = None
13    found = False
14    msg = "reimported"
15
16    for first in context.body:
17        if first is node:
18            continue
19        if first.scope() is node.scope() and first.fromlineno > node.fromlineno:
20            continue
21        if isinstance(first, nodes.Import):
22            if any(fullname == iname[0] for iname in first.names):
23                found = True
24                break
25            for imported_name, imported_alias in first.names:
26                if not imported_alias and imported_name == alias:
27                    found = True
28                    msg = "shadowed-import"
29                    break
30            if found:
31                break
32        elif isinstance(first, nodes.ImportFrom):
33            if level == first.level:
34                for imported_name, imported_alias in first.names:
35                    if fullname == f"{first.modname}.{imported_name}":
36                        found = True
37                        break
38                    if (
39                        name != "*"
40                        and name == imported_name
41                        and not (alias or imported_alias)
42                    ):
43                        found = True
44                        break
45                    if not imported_alias and imported_name == alias:
46                        found = True
47                        msg = "shadowed-import"
48                        break
49                if found:
50                    break
51    if found and not astroid.are_exclusive(first, node):
52        return first, msg
53    return None, None
            

Path 31: 3 calls (0.0)

→ node ImportFrom (3)

→ context Module (3)

→ name 'a' (1) 'c' (1) '_d' (1)

→ base 'city' (3)

→ level None (3)

→ alias None (3)

↩ return tuple (3)

22 run 19 not run

1def _get_first_import(
2    node: ImportNode,
3    context: nodes.LocalsDictNodeNG,
4    name: str,
5    base: str | None,
6    level: int | None,
7    alias: str | None,
8) -> tuple[nodes.Import | nodes.ImportFrom | None, str | None]:
9    """Return the node where [base.]<name> is imported or None if not found."""
10    fullname = f"{base}.{name}" if base else name
11
12    first = None
13    found = False
14    msg = "reimported"
15
16    for first in context.body:
17        if first is node:
18            continue
19        if first.scope() is node.scope() and first.fromlineno > node.fromlineno:
20            continue
21        if isinstance(first, nodes.Import):
22            if any(fullname == iname[0] for iname in first.names):
23                found = True
24                break
25            for imported_name, imported_alias in first.names:
26                if not imported_alias and imported_name == alias:
27                    found = True
28                    msg = "shadowed-import"
29                    break
30            if found:
31                break
32        elif isinstance(first, nodes.ImportFrom):
33            if level == first.level:
34                for imported_name, imported_alias in first.names:
35                    if fullname == f"{first.modname}.{imported_name}":
36                        found = True
37                        break
38                    if (
39                        name != "*"
40                        and name == imported_name
41                        and not (alias or imported_alias)
42                    ):
43                        found = True
44                        break
45                    if not imported_alias and imported_name == alias:
46                        found = True
47                        msg = "shadowed-import"
48                        break
49                if found:
50                    break
51    if found and not astroid.are_exclusive(first, node):
52        return first, msg
53    return None, None
            

Path 32: 3 calls (0.0)

→ node ImportFrom (2) Import (1)

→ context Module (3)

→ name 'foo' (2) 'pandas.core.algorithms' (1)

→ base '' (2) None (1)

→ level 1 (2) None (1)

→ alias 'bar' (2) 'algos' (1)

↩ return tuple (3)

27 run 14 not run

1def _get_first_import(
2    node: ImportNode,
3    context: nodes.LocalsDictNodeNG,
4    name: str,
5    base: str | None,
6    level: int | None,
7    alias: str | None,
8) -> tuple[nodes.Import | nodes.ImportFrom | None, str | None]:
9    """Return the node where [base.]<name> is imported or None if not found."""
10    fullname = f"{base}.{name}" if base else name
11
12    first = None
13    found = False
14    msg = "reimported"
15
16    for first in context.body:
17        if first is node:
18            continue
19        if first.scope() is node.scope() and first.fromlineno > node.fromlineno:
20            continue
21        if isinstance(first, nodes.Import):
22            if any(fullname == iname[0] for iname in first.names):
23                found = True
24                break
25            for imported_name, imported_alias in first.names:
26                if not imported_alias and imported_name == alias:
27                    found = True
28                    msg = "shadowed-import"
29                    break
30            if found:
31                break
32        elif isinstance(first, nodes.ImportFrom):
33            if level == first.level:
34                for imported_name, imported_alias in first.names:
35                    if fullname == f"{first.modname}.{imported_name}":
36                        found = True
37                        break
38                    if (
39                        name != "*"
40                        and name == imported_name
41                        and not (alias or imported_alias)
42                    ):
43                        found = True
44                        break
45                    if not imported_alias and imported_name == alias:
46                        found = True
47                        msg = "shadowed-import"
48                        break
49                if found:
50                    break
51    if found and not astroid.are_exclusive(first, node):
52        return first, msg
53    return None, None
            

Path 33: 3 calls (0.0)

→ node ImportFrom (3)

→ context Module (3)

→ name '*' (3)

→ base 'rie' (1) 'itertools' (1) 'os' (1)

→ level None (3)

→ alias None (3)

↩ return (None, None) (3)

24 run 17 not run

1def _get_first_import(
2    node: ImportNode,
3    context: nodes.LocalsDictNodeNG,
4    name: str,
5    base: str | None,
6    level: int | None,
7    alias: str | None,
8) -> tuple[nodes.Import | nodes.ImportFrom | None, str | None]:
9    """Return the node where [base.]<name> is imported or None if not found."""
10    fullname = f"{base}.{name}" if base else name
11
12    first = None
13    found = False
14    msg = "reimported"
15
16    for first in context.body:
17        if first is node:
18            continue
19        if first.scope() is node.scope() and first.fromlineno > node.fromlineno:
20            continue
21        if isinstance(first, nodes.Import):
22            if any(fullname == iname[0] for iname in first.names):
23                found = True
24                break
25            for imported_name, imported_alias in first.names:
26                if not imported_alias and imported_name == alias:
27                    found = True
28                    msg = "shadowed-import"
29                    break
30            if found:
31                break
32        elif isinstance(first, nodes.ImportFrom):
33            if level == first.level:
34                for imported_name, imported_alias in first.names:
35                    if fullname == f"{first.modname}.{imported_name}":
36                        found = True
37                        break
38                    if (
39                        name != "*"
40                        and name == imported_name
41                        and not (alias or imported_alias)
42                    ):
43                        found = True
44                        break
45                    if not imported_alias and imported_name == alias:
46                        found = True
47                        msg = "shadowed-import"
48                        break
49                if found:
50                    break
51    if found and not astroid.are_exclusive(first, node):
52        return first, msg
53    return None, None
            

Path 34: 3 calls (0.0)

→ node Import (2) ImportFrom (1)

→ context Module (3)

→ name 'exists' (1) 'email.encoders' (1) 'pandas._libs.algos' (1)

→ base None (2) 'os.path' (1)

→ level None (3)

→ alias None (2) 'algos' (1)

↩ return tuple (3)

26 run 15 not run

1def _get_first_import(
2    node: ImportNode,
3    context: nodes.LocalsDictNodeNG,
4    name: str,
5    base: str | None,
6    level: int | None,
7    alias: str | None,
8) -> tuple[nodes.Import | nodes.ImportFrom | None, str | None]:
9    """Return the node where [base.]<name> is imported or None if not found."""
10    fullname = f"{base}.{name}" if base else name
11
12    first = None
13    found = False
14    msg = "reimported"
15
16    for first in context.body:
17        if first is node:
18            continue
19        if first.scope() is node.scope() and first.fromlineno > node.fromlineno:
20            continue
21        if isinstance(first, nodes.Import):
22            if any(fullname == iname[0] for iname in first.names):
23                found = True
24                break
25            for imported_name, imported_alias in first.names:
26                if not imported_alias and imported_name == alias:
27                    found = True
28                    msg = "shadowed-import"
29                    break
30            if found:
31                break
32        elif isinstance(first, nodes.ImportFrom):
33            if level == first.level:
34                for imported_name, imported_alias in first.names:
35                    if fullname == f"{first.modname}.{imported_name}":
36                        found = True
37                        break
38                    if (
39                        name != "*"
40                        and name == imported_name
41                        and not (alias or imported_alias)
42                    ):
43                        found = True
44                        break
45                    if not imported_alias and imported_name == alias:
46                        found = True
47                        msg = "shadowed-import"
48                        break
49                if found:
50                    break
51    if found and not astroid.are_exclusive(first, node):
52        return first, msg
53    return None, None
            

Path 35: 3 calls (0.0)

→ node ImportFrom (3)

→ context Module (3)

→ name '*' (3)

→ base 'unused_import_py30' (1) 'unknown.package' (1) 'UNINFERABLE' (1)

→ level None (2) 1 (1)

→ alias None (3)

↩ return (None, None) (3)

19 run 22 not run

1def _get_first_import(
2    node: ImportNode,
3    context: nodes.LocalsDictNodeNG,
4    name: str,
5    base: str | None,
6    level: int | None,
7    alias: str | None,
8) -> tuple[nodes.Import | nodes.ImportFrom | None, str | None]:
9    """Return the node where [base.]<name> is imported or None if not found."""
10    fullname = f"{base}.{name}" if base else name
11
12    first = None
13    found = False
14    msg = "reimported"
15
16    for first in context.body:
17        if first is node:
18            continue
19        if first.scope() is node.scope() and first.fromlineno > node.fromlineno:
20            continue
21        if isinstance(first, nodes.Import):
22            if any(fullname == iname[0] for iname in first.names):
23                found = True
24                break
25            for imported_name, imported_alias in first.names:
26                if not imported_alias and imported_name == alias:
27                    found = True
28                    msg = "shadowed-import"
29                    break
30            if found:
31                break
32        elif isinstance(first, nodes.ImportFrom):
33            if level == first.level:
34                for imported_name, imported_alias in first.names:
35                    if fullname == f"{first.modname}.{imported_name}":
36                        found = True
37                        break
38                    if (
39                        name != "*"
40                        and name == imported_name
41                        and not (alias or imported_alias)
42                    ):
43                        found = True
44                        break
45                    if not imported_alias and imported_name == alias:
46                        found = True
47                        msg = "shadowed-import"
48                        break
49                if found:
50                    break
51    if found and not astroid.are_exclusive(first, node):
52        return first, msg
53    return None, None
            

Path 36: 2 calls (0.0)

→ node ImportFrom (2)

→ context Module (2)

→ name 'LstT' (2)

→ base 'a' (2)

→ level 1 (2)

→ alias None (2)

↩ return (None, None) (2)

13 run 28 not run

1def _get_first_import(
2    node: ImportNode,
3    context: nodes.LocalsDictNodeNG,
4    name: str,
5    base: str | None,
6    level: int | None,
7    alias: str | None,
8) -> tuple[nodes.Import | nodes.ImportFrom | None, str | None]:
9    """Return the node where [base.]<name> is imported or None if not found."""
10    fullname = f"{base}.{name}" if base else name
11
12    first = None
13    found = False
14    msg = "reimported"
15
16    for first in context.body:
17        if first is node:
18            continue
19        if first.scope() is node.scope() and first.fromlineno > node.fromlineno:
20            continue
21        if isinstance(first, nodes.Import):
22            if any(fullname == iname[0] for iname in first.names):
23                found = True
24                break
25            for imported_name, imported_alias in first.names:
26                if not imported_alias and imported_name == alias:
27                    found = True
28                    msg = "shadowed-import"
29                    break
30            if found:
31                break
32        elif isinstance(first, nodes.ImportFrom):
33            if level == first.level:
34                for imported_name, imported_alias in first.names:
35                    if fullname == f"{first.modname}.{imported_name}":
36                        found = True
37                        break
38                    if (
39                        name != "*"
40                        and name == imported_name
41                        and not (alias or imported_alias)
42                    ):
43                        found = True
44                        break
45                    if not imported_alias and imported_name == alias:
46                        found = True
47                        msg = "shadowed-import"
48                        break
49                if found:
50                    break
51    if found and not astroid.are_exclusive(first, node):
52        return first, msg
53    return None, None
            

Path 37: 2 calls (0.0)

→ node ImportFrom (2)

→ context Module (2)

→ name 'OrderedDict' (1) 'Path' (1)

→ base 'collections' (1) 'pathlib' (1)

→ level None (2)

→ alias 'o_dict' (1) None (1)

↩ return tuple (2)

18 run 23 not run

1def _get_first_import(
2    node: ImportNode,
3    context: nodes.LocalsDictNodeNG,
4    name: str,
5    base: str | None,
6    level: int | None,
7    alias: str | None,
8) -> tuple[nodes.Import | nodes.ImportFrom | None, str | None]:
9    """Return the node where [base.]<name> is imported or None if not found."""
10    fullname = f"{base}.{name}" if base else name
11
12    first = None
13    found = False
14    msg = "reimported"
15
16    for first in context.body:
17        if first is node:
18            continue
19        if first.scope() is node.scope() and first.fromlineno > node.fromlineno:
20            continue
21        if isinstance(first, nodes.Import):
22            if any(fullname == iname[0] for iname in first.names):
23                found = True
24                break
25            for imported_name, imported_alias in first.names:
26                if not imported_alias and imported_name == alias:
27                    found = True
28                    msg = "shadowed-import"
29                    break
30            if found:
31                break
32        elif isinstance(first, nodes.ImportFrom):
33            if level == first.level:
34                for imported_name, imported_alias in first.names:
35                    if fullname == f"{first.modname}.{imported_name}":
36                        found = True
37                        break
38                    if (
39                        name != "*"
40                        and name == imported_name
41                        and not (alias or imported_alias)
42                    ):
43                        found = True
44                        break
45                    if not imported_alias and imported_name == alias:
46                        found = True
47                        msg = "shadowed-import"
48                        break
49                if found:
50                    break
51    if found and not astroid.are_exclusive(first, node):
52        return first, msg
53    return None, None
            

Path 38: 2 calls (0.0)

→ node ImportFrom (2)

→ context Module (2)

→ name 'foobar' (2)

→ base 'foo.bar' (2)

→ level 2 (2)

→ alias 'foobar' (1) 'anotherfoobar' (1)

↩ return tuple (2)

⚠ exception GeneratorExit (2)

18 run 23 not run

1def _get_first_import(
2    node: ImportNode,
3    context: nodes.LocalsDictNodeNG,
4    name: str,
5    base: str | None,
6    level: int | None,
7    alias: str | None,
8) -> tuple[nodes.Import | nodes.ImportFrom | None, str | None]:
9    """Return the node where [base.]<name> is imported or None if not found."""
10    fullname = f"{base}.{name}" if base else name
11
12    first = None
13    found = False
14    msg = "reimported"
15
16    for first in context.body:
17        if first is node:
18            continue
19        if first.scope() is node.scope() and first.fromlineno > node.fromlineno:
20            continue
21        if isinstance(first, nodes.Import):
22            if any(fullname == iname[0] for iname in first.names):
23                found = True
24                break
25            for imported_name, imported_alias in first.names:
26                if not imported_alias and imported_name == alias:
27                    found = True
28                    msg = "shadowed-import"
29                    break
30            if found:
31                break
32        elif isinstance(first, nodes.ImportFrom):
33            if level == first.level:
34                for imported_name, imported_alias in first.names:
35                    if fullname == f"{first.modname}.{imported_name}":
36                        found = True
37                        break
38                    if (
39                        name != "*"
40                        and name == imported_name
41                        and not (alias or imported_alias)
42                    ):
43                        found = True
44                        break
45                    if not imported_alias and imported_name == alias:
46                        found = True
47                        msg = "shadowed-import"
48                        break
49                if found:
50                    break
51    if found and not astroid.are_exclusive(first, node):
52        return first, msg
53    return None, None
            

Path 39: 2 calls (0.0)

→ node ImportFrom (2)

→ context Module (2)

→ name 'open' (2)

→ base 'os' (2)

→ level None (2)

→ alias None (2)

↩ return tuple (2)

22 run 19 not run

1def _get_first_import(
2    node: ImportNode,
3    context: nodes.LocalsDictNodeNG,
4    name: str,
5    base: str | None,
6    level: int | None,
7    alias: str | None,
8) -> tuple[nodes.Import | nodes.ImportFrom | None, str | None]:
9    """Return the node where [base.]<name> is imported or None if not found."""
10    fullname = f"{base}.{name}" if base else name
11
12    first = None
13    found = False
14    msg = "reimported"
15
16    for first in context.body:
17        if first is node:
18            continue
19        if first.scope() is node.scope() and first.fromlineno > node.fromlineno:
20            continue
21        if isinstance(first, nodes.Import):
22            if any(fullname == iname[0] for iname in first.names):
23                found = True
24                break
25            for imported_name, imported_alias in first.names:
26                if not imported_alias and imported_name == alias:
27                    found = True
28                    msg = "shadowed-import"
29                    break
30            if found:
31                break
32        elif isinstance(first, nodes.ImportFrom):
33            if level == first.level:
34                for imported_name, imported_alias in first.names:
35                    if fullname == f"{first.modname}.{imported_name}":
36                        found = True
37                        break
38                    if (
39                        name != "*"
40                        and name == imported_name
41                        and not (alias or imported_alias)
42                    ):
43                        found = True
44                        break
45                    if not imported_alias and imported_name == alias:
46                        found = True
47                        msg = "shadowed-import"
48                        break
49                if found:
50                    break
51    if found and not astroid.are_exclusive(first, node):
52        return first, msg
53    return None, None
            

Path 40: 2 calls (0.0)

→ node ImportFrom (1) Import (1)

→ context Module (2)

→ name 'CustomPath' (1) 'FastAPI.Path' (1)

→ base 'some_other_lib' (1) None (1)

→ level None (2)

→ alias 'Path' (2)

↩ return tuple (2)

23 run 18 not run

1def _get_first_import(
2    node: ImportNode,
3    context: nodes.LocalsDictNodeNG,
4    name: str,
5    base: str | None,
6    level: int | None,
7    alias: str | None,
8) -> tuple[nodes.Import | nodes.ImportFrom | None, str | None]:
9    """Return the node where [base.]<name> is imported or None if not found."""
10    fullname = f"{base}.{name}" if base else name
11
12    first = None
13    found = False
14    msg = "reimported"
15
16    for first in context.body:
17        if first is node:
18            continue
19        if first.scope() is node.scope() and first.fromlineno > node.fromlineno:
20            continue
21        if isinstance(first, nodes.Import):
22            if any(fullname == iname[0] for iname in first.names):
23                found = True
24                break
25            for imported_name, imported_alias in first.names:
26                if not imported_alias and imported_name == alias:
27                    found = True
28                    msg = "shadowed-import"
29                    break
30            if found:
31                break
32        elif isinstance(first, nodes.ImportFrom):
33            if level == first.level:
34                for imported_name, imported_alias in first.names:
35                    if fullname == f"{first.modname}.{imported_name}":
36                        found = True
37                        break
38                    if (
39                        name != "*"
40                        and name == imported_name
41                        and not (alias or imported_alias)
42                    ):
43                        found = True
44                        break
45                    if not imported_alias and imported_name == alias:
46                        found = True
47                        msg = "shadowed-import"
48                        break
49                if found:
50                    break
51    if found and not astroid.are_exclusive(first, node):
52        return first, msg
53    return None, None
            

Path 41: 2 calls (0.0)

→ node ImportFrom (1) Import (1)

→ context Module (2)

→ name 'CustomHello' (1) 'astroid' (1)

→ base 'goodbye' (1) None (1)

→ level None (2)

→ alias 'Hello' (1) 'typing' (1)

↩ return tuple (2)

27 run 14 not run

1def _get_first_import(
2    node: ImportNode,
3    context: nodes.LocalsDictNodeNG,
4    name: str,
5    base: str | None,
6    level: int | None,
7    alias: str | None,
8) -> tuple[nodes.Import | nodes.ImportFrom | None, str | None]:
9    """Return the node where [base.]<name> is imported or None if not found."""
10    fullname = f"{base}.{name}" if base else name
11
12    first = None
13    found = False
14    msg = "reimported"
15
16    for first in context.body:
17        if first is node:
18            continue
19        if first.scope() is node.scope() and first.fromlineno > node.fromlineno:
20            continue
21        if isinstance(first, nodes.Import):
22            if any(fullname == iname[0] for iname in first.names):
23                found = True
24                break
25            for imported_name, imported_alias in first.names:
26                if not imported_alias and imported_name == alias:
27                    found = True
28                    msg = "shadowed-import"
29                    break
30            if found:
31                break
32        elif isinstance(first, nodes.ImportFrom):
33            if level == first.level:
34                for imported_name, imported_alias in first.names:
35                    if fullname == f"{first.modname}.{imported_name}":
36                        found = True
37                        break
38                    if (
39                        name != "*"
40                        and name == imported_name
41                        and not (alias or imported_alias)
42                    ):
43                        found = True
44                        break
45                    if not imported_alias and imported_name == alias:
46                        found = True
47                        msg = "shadowed-import"
48                        break
49                if found:
50                    break
51    if found and not astroid.are_exclusive(first, node):
52        return first, msg
53    return None, None
            

Path 42: 2 calls (0.0)

→ node Import (2)

→ context Module (2)

→ name 'os' (2)

→ base None (2)

→ level None (2)

→ alias 'o' (1) None (1)

↩ return tuple (2)

⚠ exception GeneratorExit (2)

16 run 25 not run

1def _get_first_import(
2    node: ImportNode,
3    context: nodes.LocalsDictNodeNG,
4    name: str,
5    base: str | None,
6    level: int | None,
7    alias: str | None,
8) -> tuple[nodes.Import | nodes.ImportFrom | None, str | None]:
9    """Return the node where [base.]<name> is imported or None if not found."""
10    fullname = f"{base}.{name}" if base else name
11
12    first = None
13    found = False
14    msg = "reimported"
15
16    for first in context.body:
17        if first is node:
18            continue
19        if first.scope() is node.scope() and first.fromlineno > node.fromlineno:
20            continue
21        if isinstance(first, nodes.Import):
22            if any(fullname == iname[0] for iname in first.names):
23                found = True
24                break
25            for imported_name, imported_alias in first.names:
26                if not imported_alias and imported_name == alias:
27                    found = True
28                    msg = "shadowed-import"
29                    break
30            if found:
31                break
32        elif isinstance(first, nodes.ImportFrom):
33            if level == first.level:
34                for imported_name, imported_alias in first.names:
35                    if fullname == f"{first.modname}.{imported_name}":
36                        found = True
37                        break
38                    if (
39                        name != "*"
40                        and name == imported_name
41                        and not (alias or imported_alias)
42                    ):
43                        found = True
44                        break
45                    if not imported_alias and imported_name == alias:
46                        found = True
47                        msg = "shadowed-import"
48                        break
49                if found:
50                    break
51    if found and not astroid.are_exclusive(first, node):
52        return first, msg
53    return None, None
            

Path 43: 2 calls (0.0)

→ node ImportFrom (2)

→ context Module (2)

→ name '*' (2)

→ base 'unused_global_variable1' (1) 'abc' (1)

→ level 1 (1) None (1)

→ alias None (2)

↩ return (None, None) (2)

20 run 21 not run

1def _get_first_import(
2    node: ImportNode,
3    context: nodes.LocalsDictNodeNG,
4    name: str,
5    base: str | None,
6    level: int | None,
7    alias: str | None,
8) -> tuple[nodes.Import | nodes.ImportFrom | None, str | None]:
9    """Return the node where [base.]<name> is imported or None if not found."""
10    fullname = f"{base}.{name}" if base else name
11
12    first = None
13    found = False
14    msg = "reimported"
15
16    for first in context.body:
17        if first is node:
18            continue
19        if first.scope() is node.scope() and first.fromlineno > node.fromlineno:
20            continue
21        if isinstance(first, nodes.Import):
22            if any(fullname == iname[0] for iname in first.names):
23                found = True
24                break
25            for imported_name, imported_alias in first.names:
26                if not imported_alias and imported_name == alias:
27                    found = True
28                    msg = "shadowed-import"
29                    break
30            if found:
31                break
32        elif isinstance(first, nodes.ImportFrom):
33            if level == first.level:
34                for imported_name, imported_alias in first.names:
35                    if fullname == f"{first.modname}.{imported_name}":
36                        found = True
37                        break
38                    if (
39                        name != "*"
40                        and name == imported_name
41                        and not (alias or imported_alias)
42                    ):
43                        found = True
44                        break
45                    if not imported_alias and imported_name == alias:
46                        found = True
47                        msg = "shadowed-import"
48                        break
49                if found:
50                    break
51    if found and not astroid.are_exclusive(first, node):
52        return first, msg
53    return None, None
            

Path 44: 2 calls (0.0)

→ node Import (2)

→ context Module (2)

→ name 'time' (2)

→ base None (2)

→ level None (2)

→ alias None (2)

↩ return tuple (2)

⚠ exception GeneratorExit (2)

14 run 27 not run

1def _get_first_import(
2    node: ImportNode,
3    context: nodes.LocalsDictNodeNG,
4    name: str,
5    base: str | None,
6    level: int | None,
7    alias: str | None,
8) -> tuple[nodes.Import | nodes.ImportFrom | None, str | None]:
9    """Return the node where [base.]<name> is imported or None if not found."""
10    fullname = f"{base}.{name}" if base else name
11
12    first = None
13    found = False
14    msg = "reimported"
15
16    for first in context.body:
17        if first is node:
18            continue
19        if first.scope() is node.scope() and first.fromlineno > node.fromlineno:
20            continue
21        if isinstance(first, nodes.Import):
22            if any(fullname == iname[0] for iname in first.names):
23                found = True
24                break
25            for imported_name, imported_alias in first.names:
26                if not imported_alias and imported_name == alias:
27                    found = True
28                    msg = "shadowed-import"
29                    break
30            if found:
31                break
32        elif isinstance(first, nodes.ImportFrom):
33            if level == first.level:
34                for imported_name, imported_alias in first.names:
35                    if fullname == f"{first.modname}.{imported_name}":
36                        found = True
37                        break
38                    if (
39                        name != "*"
40                        and name == imported_name
41                        and not (alias or imported_alias)
42                    ):
43                        found = True
44                        break
45                    if not imported_alias and imported_name == alias:
46                        found = True
47                        msg = "shadowed-import"
48                        break
49                if found:
50                    break
51    if found and not astroid.are_exclusive(first, node):
52        return first, msg
53    return None, None
            

Path 45: 1 calls (0.0)

→ node ImportFrom (1)

→ context Module (1)

→ name '_private' (1)

→ base 'other_file' (1)

→ level 1 (1)

→ alias None (1)

↩ return tuple (1)

26 run 15 not run

1def _get_first_import(
2    node: ImportNode,
3    context: nodes.LocalsDictNodeNG,
4    name: str,
5    base: str | None,
6    level: int | None,
7    alias: str | None,
8) -> tuple[nodes.Import | nodes.ImportFrom | None, str | None]:
9    """Return the node where [base.]<name> is imported or None if not found."""
10    fullname = f"{base}.{name}" if base else name
11
12    first = None
13    found = False
14    msg = "reimported"
15
16    for first in context.body:
17        if first is node:
18            continue
19        if first.scope() is node.scope() and first.fromlineno > node.fromlineno:
20            continue
21        if isinstance(first, nodes.Import):
22            if any(fullname == iname[0] for iname in first.names):
23                found = True
24                break
25            for imported_name, imported_alias in first.names:
26                if not imported_alias and imported_name == alias:
27                    found = True
28                    msg = "shadowed-import"
29                    break
30            if found:
31                break
32        elif isinstance(first, nodes.ImportFrom):
33            if level == first.level:
34                for imported_name, imported_alias in first.names:
35                    if fullname == f"{first.modname}.{imported_name}":
36                        found = True
37                        break
38                    if (
39                        name != "*"
40                        and name == imported_name
41                        and not (alias or imported_alias)
42                    ):
43                        found = True
44                        break
45                    if not imported_alias and imported_name == alias:
46                        found = True
47                        msg = "shadowed-import"
48                        break
49                if found:
50                    break
51    if found and not astroid.are_exclusive(first, node):
52        return first, msg
53    return None, None
            

Path 46: 1 calls (0.0)

→ node ImportFrom (1)

→ context Module (1)

→ name 'b' (1)

→ base 'a' (1)

→ level 12 (1)

→ alias None (1)

↩ return (None, None) (1)

17 run 24 not run

1def _get_first_import(
2    node: ImportNode,
3    context: nodes.LocalsDictNodeNG,
4    name: str,
5    base: str | None,
6    level: int | None,
7    alias: str | None,
8) -> tuple[nodes.Import | nodes.ImportFrom | None, str | None]:
9    """Return the node where [base.]<name> is imported or None if not found."""
10    fullname = f"{base}.{name}" if base else name
11
12    first = None
13    found = False
14    msg = "reimported"
15
16    for first in context.body:
17        if first is node:
18            continue
19        if first.scope() is node.scope() and first.fromlineno > node.fromlineno:
20            continue
21        if isinstance(first, nodes.Import):
22            if any(fullname == iname[0] for iname in first.names):
23                found = True
24                break
25            for imported_name, imported_alias in first.names:
26                if not imported_alias and imported_name == alias:
27                    found = True
28                    msg = "shadowed-import"
29                    break
30            if found:
31                break
32        elif isinstance(first, nodes.ImportFrom):
33            if level == first.level:
34                for imported_name, imported_alias in first.names:
35                    if fullname == f"{first.modname}.{imported_name}":
36                        found = True
37                        break
38                    if (
39                        name != "*"
40                        and name == imported_name
41                        and not (alias or imported_alias)
42                    ):
43                        found = True
44                        break
45                    if not imported_alias and imported_name == alias:
46                        found = True
47                        msg = "shadowed-import"
48                        break
49                if found:
50                    break
51    if found and not astroid.are_exclusive(first, node):
52        return first, msg
53    return None, None