-- Type checker test cases dealing with modules and imports.

-- Towards the end there are tests for PEP 420 (namespace packages, i.e. __init__.py-less packages).

[case testAccessImportedDefinitions]

import m

import typing

m.f() # E: Too few arguments for "f"

m.f(object()) # E: Argument 1 to "f" has incompatible type "object"; expected "A"

m.x = object() # E: Incompatible types in assignment (expression has type "object", variable has type "A")

m.f(m.A())

m.x = m.A()

[file m.py]

class A: pass

def f(a: A) -> None: pass

x = A()

[case testAccessImportedDefinitions]

import m

import typing

m.f(object()) # E: Argument 1 to "f" has incompatible type "object"; expected "A"

m.f(m.A())

[file m.py]

class A: pass

def f(a: A) -> None: pass

[case testAccessImportedDefinitions2]

from m import f, A

import typing

f(object()) # E: Argument 1 to "f" has incompatible type "object"; expected "A"

f(A())

[file m.py]

class A: pass

def f(a: A) -> None: pass

[case testImportedExceptionType]

import m

import typing

try:

pass

except m.Err:

pass

except m.Bad: # E: Exception type must be derived from BaseException

pass

[file m.py]

class Err(BaseException): pass

class Bad: pass

[builtins fixtures/exception.pyi]

[case testImportedExceptionType2]

from m import Err, Bad

import typing

try:

pass

except Err:

pass

except Bad: # E: Exception type must be derived from BaseException

pass

[file m.py]

class Err(BaseException): pass

class Bad: pass

[builtins fixtures/exception.pyi]

[case testImportWithinBlock]

import typing

if 1:

import m

m.a = m.b # E: Incompatible types in assignment (expression has type "B", variable has type "A")

m.a = m.a

m.f()

m.f(m.a) # E: Too many arguments for "f"

m.a = m.A()

m.a = m.B() # E: Incompatible types in assignment (expression has type "B", variable has type "A")

[file m.py]

class A: pass

class B: pass

a = A()

b = B()

def f() -> None: pass

[case testImportWithinFunction]

import typing

def f() -> None:

from m import a, b, f, A, B

if int():

a = b \

# E: Incompatible types in assignment (expression has type "B", variable has type "A")

a = a

f()

f(a) # E: Too many arguments for "f"

a = A()

a = B() \

# E: Incompatible types in assignment (expression has type "B", variable has type "A")

[file m.py]

class A: pass

class B: pass

a = A()

b = B()

def f() -> None: pass

[out]

[case testImportWithinMethod]

import typing

class C:

def f(self) -> None:

from m import *

if int():

a = b # E: Incompatible types in assignment (expression has type "B", variable has type "A")

a = a

f()

f(a) # E: Too many arguments for "f"

a = A()

a = B() # E: Incompatible types in assignment (expression has type "B", variable has type "A")

[file m.py]

class A: pass

class B: pass

a = A()

b = B()

def f() -> None: pass

[out]

[case testImportWithinClassBody]

import typing

class C:

import m

m.f()

m.f(C) # E: Too many arguments for "f"

[file m.py]

def f() -> None: pass

[out]

[case testImportWithinClassBody2]

import typing

class C:

from m import f

f()

f(C) # E: Too many arguments for "f"

[file m.py]

def f() -> None: pass

[out]

[case testImportWithStub]

import _m

_m.f("hola")

[file _m.pyi]

def f(c:str) -> None: pass

[out]

[case testImportWithStubIncompatibleType]

import _m

_m.f("hola")

_m.f(12) # E: Argument 1 to "f" has incompatible type "int"; expected "str"

[file _m.py]

def f(c):

print(c)

[file _m.pyi]

def f(c:str) -> None: pass

[case testInvalidOperationsOnModules]

import m

import typing

class A: pass

m() # E: Module not callable

a = m # type: A # E: Incompatible types in assignment (expression has type Module, variable has type "A")

m + None # E: Unsupported left operand type for + (Module)

[file m.py]

[builtins fixtures/module.pyi]

[case testNameDefinedInDifferentModule]

import m, n

import typing

m.x # E: Module has no attribute "x"

[file m.py]

y = object()

[file n.py]

x = object()

[builtins fixtures/module.pyi]

[case testChainedAssignmentAndImports]

import m

i, s = None, None # type: (int, str)

if int():

i = m.x

if int():

i = m.y

if int():

s = m.x # E: Incompatible types in assignment (expression has type "int", variable has type "str")

if int():

s = m.y # E: Incompatible types in assignment (expression has type "int", variable has type "str")

[file m.py]

x = y = 1

[builtins fixtures/primitives.pyi]

[case testConditionalFunctionDefinitionAndImports]

import m

import typing

m.f(1)

m.f('x') # E: Argument 1 to "f" has incompatible type "str"; expected "int"

[file m.py]

x = object()

if x:

def f(x: int) -> None: pass

else:

def f(x: int) -> None: pass

[case testTypeCheckWithUnknownModule]

import nonexistent

None + ''

[out]

main:1: error: Cannot find module named 'nonexistent'

main:1: note: See https://mypy.readthedocs.io/en/latest/running_mypy.html#missing-imports

main:2: error: Unsupported left operand type for + ("None")

[case testTypeCheckWithUnknownModule2]

import m, nonexistent

None + ''

m.x = 1

m.x = ''

[file m.py]

x = 1

[out]

main:1: error: Cannot find module named 'nonexistent'

main:1: note: See https://mypy.readthedocs.io/en/latest/running_mypy.html#missing-imports

main:2: error: Unsupported left operand type for + ("None")

main:4: error: Incompatible types in assignment (expression has type "str", variable has type "int")

[case testTypeCheckWithUnknownModule3]

import nonexistent, m

None + ''

m.x = 1

m.x = ''

[file m.py]

x = 1

[out]

main:1: error: Cannot find module named 'nonexistent'

main:1: note: See https://mypy.readthedocs.io/en/latest/running_mypy.html#missing-imports

main:2: error: Unsupported left operand type for + ("None")

main:4: error: Incompatible types in assignment (expression has type "str", variable has type "int")

[case testTypeCheckWithUnknownModule4]

import nonexistent, another

None + ''

[out]

main:1: error: Cannot find module named 'nonexistent'

main:1: note: See https://mypy.readthedocs.io/en/latest/running_mypy.html#missing-imports

main:1: error: Cannot find module named 'another'

main:2: error: Unsupported left operand type for + ("None")

[case testTypeCheckWithUnknownModule5]

import nonexistent as x

None + ''

[out]

main:1: error: Cannot find module named 'nonexistent'

main:1: note: See https://mypy.readthedocs.io/en/latest/running_mypy.html#missing-imports

main:2: error: Unsupported left operand type for + ("None")

[case testTypeCheckWithUnknownModuleUsingFromImport]

from nonexistent import x

None + ''

[out]

main:1: error: Cannot find module named 'nonexistent'

main:1: note: See https://mypy.readthedocs.io/en/latest/running_mypy.html#missing-imports

main:2: error: Unsupported left operand type for + ("None")

[case testTypeCheckWithUnknownModuleUsingImportStar]

from nonexistent import *

None + ''

[out]

main:1: error: Cannot find module named 'nonexistent'

main:1: note: See https://mypy.readthedocs.io/en/latest/running_mypy.html#missing-imports

main:2: error: Unsupported left operand type for + ("None")

[case testAccessingUnknownModule]

import xyz

xyz.foo()

xyz()

[out]

main:1: error: Cannot find module named 'xyz'

main:1: note: See https://mypy.readthedocs.io/en/latest/running_mypy.html#missing-imports

[case testAccessingUnknownModule2]

import xyz, bar

xyz.foo()

bar()

[out]

main:1: error: Cannot find module named 'xyz'

main:1: note: See https://mypy.readthedocs.io/en/latest/running_mypy.html#missing-imports

main:1: error: Cannot find module named 'bar'

[case testAccessingUnknownModule3]

import xyz as z

xyz.foo()

z()

[out]

main:1: error: Cannot find module named 'xyz'

main:1: note: See https://mypy.readthedocs.io/en/latest/running_mypy.html#missing-imports

main:2: error: Name 'xyz' is not defined

[case testAccessingNameImportedFromUnknownModule]

from xyz import y, z

y.foo()

z()

[out]

main:1: error: Cannot find module named 'xyz'

main:1: note: See https://mypy.readthedocs.io/en/latest/running_mypy.html#missing-imports

[case testAccessingNameImportedFromUnknownModule2]

from xyz import *

y

[out]

main:1: error: Cannot find module named 'xyz'

main:1: note: See https://mypy.readthedocs.io/en/latest/running_mypy.html#missing-imports

main:2: error: Name 'y' is not defined

[case testAccessingNameImportedFromUnknownModule3]

from xyz import y as z

y

z

[out]

main:1: error: Cannot find module named 'xyz'

main:1: note: See https://mypy.readthedocs.io/en/latest/running_mypy.html#missing-imports

main:2: error: Name 'y' is not defined

[case testUnknownModuleRedefinition]

# Error messages differ with the new analyzer

# flags: --new-semantic-analyzer

import xab # E: Cannot find module named 'xab' # N: See https://mypy.readthedocs.io/en/latest/running_mypy.html#missing-imports

def xab(): pass # E: Name 'xab' already defined (possibly by an import)

[case testAccessingUnknownModuleFromOtherModule]

import x

x.nonexistent.foo

x.z

[file x.py]

import nonexistent

[builtins fixtures/module.pyi]

[out]

tmp/x.py:1: error: Cannot find module named 'nonexistent'

tmp/x.py:1: note: See https://mypy.readthedocs.io/en/latest/running_mypy.html#missing-imports

main:3: error: Module has no attribute "z"

[case testUnknownModuleImportedWithinFunction]

def f():

import foobar

def foobar(): pass

foobar('')

[out]

main:2: error: Cannot find module named 'foobar'

main:2: note: See https://mypy.readthedocs.io/en/latest/running_mypy.html#missing-imports

main:4: error: Too many arguments for "foobar"

[case testUnknownModuleImportedWithinFunction2]

def f():

from foobar import x

def x(): pass

x('')

[out]

main:2: error: Cannot find module named 'foobar'

main:2: note: See https://mypy.readthedocs.io/en/latest/running_mypy.html#missing-imports

main:4: error: Too many arguments for "x"

[case testRelativeImports]

import typing

import m.a

m.a.x = m.a.y # Error

[file m/__init__.py]

[file m/a.py]

import typing

from .b import A, B, x, y

z = x

if int():

z = y # Error

[file m/b.py]

import typing

class A: pass

class B: pass

x = A()

y = B()

[out]

tmp/m/a.py:5: error: Incompatible types in assignment (expression has type "B", variable has type "A")

main:3: error: Incompatible types in assignment (expression has type "B", variable has type "A")

[case testRelativeImports2]

import typing

import m.a

m.a.x = m.a.y # E: Incompatible types in assignment (expression has type "B", variable has type "A")

[file m/__init__.py]

[file m/a.py]

import typing

from .b import A, B, x, y

[file m/b.py]

import typing

class A: pass

class B: pass

x = A()

y = B()

[case testExportedValuesInImportAll]

import typing

from m import *

_ = a

_ = b

_ = c

_ = d

_ = e

_ = f # E: Name 'f' is not defined

_ = _g # E: Name '_g' is not defined

[file m.py]

__all__ = ['a']

__all__ += ('b',)

__all__.append('c')

__all__.extend(('d', 'e'))

a = b = c = d = e = f = _g = 1

[builtins fixtures/module_all.pyi]

[case testAllMustBeSequenceStr]

import typing

__all__ = [1, 2, 3]

[builtins fixtures/module_all.pyi]

[out]

main:2: error: Type of __all__ must be "Sequence[str]", not "List[int]"

[case testAllMustBeSequenceStr_python2]

import typing

__all__ = [1, 2, 3]

[builtins_py2 fixtures/module_all_python2.pyi]

[out]

main:2: error: Type of __all__ must be "Sequence[unicode]", not "List[int]"

[case testAllUnicodeSequenceOK_python2]

import typing

__all__ = [u'a', u'b', u'c']

[builtins_py2 fixtures/module_all_python2.pyi]

[out]

[case testUnderscoreExportedValuesInImportAll]

import typing

from m import *

_ = a

_ = _b

_ = __c__

_ = ___d

_ = e

_ = f # E: Name 'f' is not defined

_ = _g # E: Name '_g' is not defined

[file m.py]

__all__ = ['a']

__all__ += ('_b',)

__all__.append('__c__')

__all__.extend(('___d', 'e'))

a = _b = __c__ = ___d = e = f = _g = 1

[builtins fixtures/module_all.pyi]

[case testEllipsisInitializerInStubFileWithType]

import m

m.x = '' # E: Incompatible types in assignment (expression has type "str", variable has type "int")

[file m.pyi]

x = ... # type: int

[case testEllipsisInitializerInStubFileWithoutType]

import m

m.x = '' # E: Incompatible types in assignment (expression has type "str", variable has type "ellipsis")

[file m.pyi]

# Ellipsis is only special with a # type: comment (not sure though if this is great)

x = ...

[case testEllipsisInitializerInModule]

x = ... # type: int # E: Incompatible types in assignment (expression has type "ellipsis", variable has type "int")

[case testEllipsisDefaultArgValueInStub]

import m

m.f(1)

m.f('') # E: Argument 1 to "f" has incompatible type "str"; expected "int"

[file m.pyi]

def f(x: int = ...) -> None: pass

[case testEllipsisDefaultArgValueInStub2]

import m

def f1(x: int = ...) -> int: return 1

def f2(x: int = '') -> int: return 1

[file m.pyi]

def g1(x: int = ...) -> int: pass

def g2(x: int = '') -> int: pass

[out]

tmp/m.pyi:2: error: Incompatible default for argument "x" (default has type "str", argument has type "int")

main:2: error: Incompatible default for argument "x" (default has type "ellipsis", argument has type "int")

main:3: error: Incompatible default for argument "x" (default has type "str", argument has type "int")

[case testEllipsisDefaultArgValueInNonStub]

def ok_1(x: int = ...) -> None: pass

def ok_2(x: int = ...) -> None: ...

def ok_3(x: int = ...) -> None: raise NotImplementedError

def ok_4(x: int = ...) -> None: raise NotImplementedError()

def ok_5(x: int = ...) -> None:

"""Docstring here"""

pass

def bad_1(x: int = ...) -> None: 1 # E: Incompatible default for argument "x" (default has type "ellipsis", argument has type "int")

def bad_2(x: int = ...) -> None: # E: Incompatible default for argument "x" (default has type "ellipsis", argument has type "int")

"""Docstring here"""

ok_1()

def bad_3(x: int = ...) -> None: # E: Incompatible default for argument "x" (default has type "ellipsis", argument has type "int")

raise Exception("Some other exception")

[builtins fixtures/exception.pyi]

[out]

[case testEllipsisDefaultArgValueInNonStubsOverload]

from typing import overload, Union

Both = Union[int, str]

@overload

def foo(x: int, y: int = ...) -> int: ...

@overload

def foo(x: str, y: str = ...) -> str: ...

def foo(x: Both, y: Both = ...) -> Both: # E: Incompatible default for argument "y" (default has type "ellipsis", argument has type "Union[int, str]")

return x

@overload

def bar(x: int, y: int = ...) -> int: ...

@overload

def bar(x: str, y: str = ...) -> str: ...

def bar(x: Both, y: Both = ...) -> Both:

raise NotImplementedError

[builtins fixtures/exception.pyi]

[out]

[case testEllipsisDefaultArgValueInNonStubsMethods]

from typing import Generic, TypeVar

from typing_extensions import Protocol

from abc import abstractmethod

T = TypeVar('T')

class Wrap(Generic[T]): ...

class MyProtocol(Protocol):

def no_impl(self, x: Wrap[int] = ...) -> int: ...

def default_impl(self, x: Wrap[int] = ...) -> int: return 3 # E: Incompatible default for argument "x" (default has type "ellipsis", argument has type "Wrap[int]")

class MyAbstractClass:

@abstractmethod

def no_impl(self, x: Wrap[int] = ...) -> int: raise NotImplementedError

@abstractmethod

def default_impl(self, x: Wrap[int] = ...) -> int: return 3 # E: Incompatible default for argument "x" (default has type "ellipsis", argument has type "Wrap[int]")

[builtins fixtures/exception.pyi]

[out]

[case testStarImportOverlapping]

from m1 import *

from m2 import *

j = ''

[file m1.py]

x = 1

[file m2.py]

x = 1

[case testStarImportOverlappingMismatch]

from m1 import *

from m2 import * # E: Incompatible import of "x" (imported name has type "int", local name has type "str")

j = ''

[file m1.py]

x = ''

[file m2.py]

x = 1

[case testStarImportOverridingLocalImports-skip]

from m1 import *

from m2 import *

x = '' # E: TODO (cannot assign str to int)

[file m1.py]

x = 1

[file m2.py]

x = 1

[case testAssignToFuncDefViaImport]

# Errors differ with the new analyzer. (Old analyzer gave error on the

# input, which is maybe better, but no error about f, which seems

# wrong)

# flags: --new-semantic-analyzer

from m import *

f = None # E: Incompatible types in assignment (expression has type "None", variable has type "Callable[[], Any]")

x = '' # E: Incompatible types in assignment (expression has type "str", variable has type "int")

[file m.py]

def f(): pass

x = 1+0

[out]

-- Conditional definitions and function redefinitions via module object

-- --------------------------------------------------------------------

[case testConditionalImportAndAssign]

try:

from m import x

except:

x = None

try:

from m import x as y

except:

y = 1 # E: Incompatible types in assignment (expression has type "int", variable has type "str")

[file m.py]

x = ''

[case testAssignAndConditionalImport]

x = ''

try:

from m import x

except:

pass

y = 1

try:

from m import x as y # E: Incompatible import of "y" (imported name has type "str", local name has type "int")

except:

pass

[file m.py]

x = ''

[case testAssignAndConditionalStarImport]

x = ''

y = 1

try:

from m import * # E: Incompatible import of "y" (imported name has type "str", local name has type "int")

except:

pass

[file m.py]

x = ''

y = ''

[case testRedefineImportedFunctionViaImport]

try:

from m import f, g

except:

def f(x): pass

def g(x): pass # E: All conditional function variants must have identical signatures

[file m.py]

def f(x): pass

def g(x, y): pass

[case testImportedVariableViaImport]

try:

from m import x

except:

from n import x # E: Incompatible import of "x" (imported name has type "str", local name has type "int")

[file m.py]

x = 1

[file n.py]

x = ''

[case testRedefineFunctionViaImport]

def f(x): pass

def g(x): pass

try:

from m import f, g # E: Incompatible import of "g" (imported name has type "Callable[[Any, Any], Any]", local name has type "Callable[[Any], Any]")

except:

pass

[file m.py]

def f(x): pass

def g(x, y): pass

[case testImportVariableAndAssignNone]

try:

from m import x

except:

x = None

[file m.py]

x = 1

[case testImportFunctionAndAssignNone]

try:

from m import f

except:

f = None

[file m.py]

def f(): pass

[case testImportFunctionAndAssignFunction]

def g(x): pass

try:

from m import f

except:

f = g

[file m.py]

def f(x): pass

[case testImportFunctionAndAssignIncompatible]

try:

from m import f

except:

f = 1 # E: Incompatible types in assignment (expression has type "int", variable has type "Callable[[], Any]")

[file m.py]

def f(): pass

[case testAssignToFuncDefViaGlobalDecl2]

import typing

from m import f

def g() -> None:

global f

f = None

if int():

f = 1 # E: Incompatible types in assignment (expression has type "int", variable has type "Callable[[], Any]")

[file m.py]

def f(): pass

[out]

[case testAssignToFuncDefViaNestedModules]

import m.n

m.n.f = None

m.n.f = 1 # E: Incompatible types in assignment (expression has type "int", variable has type "Callable[[], Any]")

[file m/__init__.py]

[file m/n.py]

def f(): pass

[out]

[case testAssignToFuncDefViaModule]

import m

m.f = None

m.f = 1 # E: Incompatible types in assignment (expression has type "int", variable has type "Callable[[], Any]")

[file m.py]

def f(): pass

[out]

[case testConditionalImportAndAssignNoneToModule]

if object():

import m

else:

m = None

m.f(1) # E: Argument 1 to "f" has incompatible type "int"; expected "str"

[file m.py]

def f(x: str) -> None: pass

[builtins fixtures/module.pyi]

[out]

[case testConditionalImportAndAssignInvalidToModule]

if object():

import m

else:

m = 1 # E: Incompatible types in assignment (expression has type "int", variable has type Module)

[file m.py]

[builtins fixtures/module.pyi]

[out]

[case testImportAndAssignToModule]

import m

m = None

m.f(1) # E: Argument 1 to "f" has incompatible type "int"; expected "str"

[file m.py]

def f(x: str) -> None: pass

[builtins fixtures/module.pyi]

[out]

-- Test cases that simulate 'mypy -m modname'

--

-- The module name to import is encoded in a comment.

[case testTypeCheckNamedModule]

# cmd: mypy -m m.a

[file m/__init__.py]

None + 1

[file m/a.py]

[out]

tmp/m/__init__.py:1: error: Unsupported left operand type for + ("None")

[case testTypeCheckNamedModule2]

# cmd: mypy -m m.a

[file m/__init__.py]

[file m/a.py]

None + 1

[out]

tmp/m/a.py:1: error: Unsupported left operand type for + ("None")

[case testTypeCheckNamedModule3]

# cmd: mypy -m m

[file m/__init__.py]

None + 1

[file m/a.py]

[out]

tmp/m/__init__.py:1: error: Unsupported left operand type for + ("None")

[case testTypeCheckNamedModule4]

# cmd: mypy -m m

[file m/__init__.py]

[file m/a.py]

None + 1 # Not analyzed.

[out]

[case testTypeCheckNamedModule5]

# cmd: mypy -m m

None + '' # Not analyzed.

[file m.py]

None + 1

[out]

tmp/m.py:1: error: Unsupported left operand type for + ("None")

[case testTypeCheckNamedModuleWithImportCycle]

# cmd: mypy -m m.a

None + 1 # Does not generate error, as this file won't be analyzed.

[file m/__init__.py]

import m.a

[file m/a.py]

[out]

[case testCheckDecoratedFuncAsAnnotWithImportCycle]

import a

[file a.py]

from typing import TypeVar

import b

T = TypeVar('T')

def idf(x: T) -> T: return x

@idf

def Session() -> None: pass

[file b.py]

MYPY = False

if MYPY:

from a import Session

def f(self, session: Session) -> None: # E: Invalid type "a.Session"

pass

[builtins fixtures/bool.pyi]

-- Checks dealing with submodules and different kinds of imports

-- -------------------------------------------------------------

[case testSubmoduleRegularImportAddsAllParents]

import a.b.c

reveal_type(a.value) # E: Revealed type is 'builtins.int'

reveal_type(a.b.value) # E: Revealed type is 'builtins.str'

reveal_type(a.b.c.value) # E: Revealed type is 'builtins.float'

b.value # E: Name 'b' is not defined

c.value # E: Name 'c' is not defined

[file a/__init__.py]

value = 3

[file a/b/__init__.py]

value = "a"

[file a/b/c.py]

value = 3.2

[out]

[case testSubmoduleImportAsDoesNotAddParents]

import a.b.c as foo

reveal_type(foo.value) # E: Revealed type is 'builtins.float'

a.value # E: Name 'a' is not defined

b.value # E: Name 'b' is not defined

c.value # E: Name 'c' is not defined

[file a/__init__.py]

value = 3

[file a/b/__init__.py]

value = "a"

[file a/b/c.py]

value = 3.2

[out]

[case testSubmoduleImportFromDoesNotAddParents]

from a import b

reveal_type(b.value) # E: Revealed type is 'builtins.str'

b.c.value # E: Module has no attribute "c"

a.value # E: Name 'a' is not defined

[file a/__init__.py]

value = 3

[file a/b/__init__.py]

value = "a"

[file a/b/c.py]

value = 3.2

[builtins fixtures/module.pyi]

[out]

[case testSubmoduleImportFromDoesNotAddParents2]

from a.b import c

reveal_type(c.value) # E: Revealed type is 'builtins.float'

a.value # E: Name 'a' is not defined

b.value # E: Name 'b' is not defined

[file a/__init__.py]

value = 3

[file a/b/__init__.py]

value = "a"

[file a/b/c.py]

value = 3.2

[out]

[case testSubmoduleRegularImportNotDirectlyAddedToParent]

import a.b.c

def accept_float(x: float) -> None: pass

accept_float(a.b.c.value)

[file a/__init__.py]

value = 3

b.value

a.b.value

[file a/b/__init__.py]

value = "a"

c.value

a.b.c.value

[file a/b/c.py]

value = 3.2

[out]

tmp/a/b/__init__.py:2: error: Name 'c' is not defined

tmp/a/b/__init__.py:3: error: Name 'a' is not defined

tmp/a/__init__.py:2: error: Name 'b' is not defined

tmp/a/__init__.py:3: error: Name 'a' is not defined

[case testSubmoduleMixingLocalAndQualifiedNames]

from a.b import MyClass

val1 = None # type: a.b.MyClass # E: Name 'a' is not defined

val2 = None # type: MyClass

[file a/__init__.py]

[file a/b.py]

class MyClass: pass

[out]

[case testSubmoduleMixingImportFrom]

import parent.child

[file parent/__init__.py]

[file parent/common.py]

class SomeClass: pass

[file parent/child.py]

from parent.common import SomeClass

from parent import common

foo = parent.common.SomeClass()

[builtins fixtures/module.pyi]

[out]

tmp/parent/child.py:3: error: Name 'parent' is not defined

[case testSubmoduleMixingImportFromAndImport]

import parent.child

[file parent/__init__.py]

[file parent/common.py]

class SomeClass: pass

[file parent/unrelated.py]

class ShouldNotLoad: pass

[file parent/child.py]

from parent.common import SomeClass

import parent

# Note, since this might be unintuitive -- when `parent.common` is loaded in any way,

# shape, or form, it's added to `parent`'s namespace, which is why the below line

# succeeds.

foo = parent.common.SomeClass()

reveal_type(foo)

bar = parent.unrelated.ShouldNotLoad()

[builtins fixtures/module.pyi]

[out]

tmp/parent/child.py:8: error: Revealed type is 'parent.common.SomeClass'

tmp/parent/child.py:9: error: Module has no attribute "unrelated"

[case testSubmoduleMixingImportFromAndImport2]

import parent.child

[file parent/__init__.py]

[file parent/common.py]

class SomeClass: pass

[file parent/child.py]

from parent import common

import parent

foo = parent.common.SomeClass()

reveal_type(foo)

[builtins fixtures/module.pyi]

[out]

tmp/parent/child.py:4: error: Revealed type is 'parent.common.SomeClass'

-- Tests repeated imports

[case testIdenticalImportFromTwice]

from a import x, y, z

from b import x, y, z

[file a.py]

from common import x, y, z

[file b.py]

from common import x, y, z

[file common.py]

x = 3

def y() -> int: return 3