usse/funda-scraper/venv/lib/python3.10/site-packages/mypyc/test-data/run-imports.test

# Test cases for imports and related features (compile and run)

[case testImports]
import testmodule

def f(x: int) -> int:
    return testmodule.factorial(5)

def g(x: int) -> int:
    from welp import foo
    return foo(x)

def test_import_basics() -> None:
    assert f(5) == 120
    assert g(5) == 5

def test_import_submodule_within_function() -> None:
    import pkg.mod
    assert pkg.x == 1
    assert pkg.mod.y == 2

def test_import_as_submodule_within_function() -> None:
    import pkg.mod as mm
    assert mm.y == 2

# TODO: Don't add local imports to globals()
#
# def test_local_import_not_in_globals() -> None:
#     import nob
#     assert 'nob' not in globals()

def test_import_module_without_stub_in_function() -> None:
    # 'virtualenv' must not have a stub in typeshed for this test case
    import virtualenv  # type: ignore
    # TODO: We shouldn't add local imports to globals()
    # assert 'virtualenv' not in globals()
    assert isinstance(virtualenv.__name__, str)

def test_import_as_module_without_stub_in_function() -> None:
    # 'virtualenv' must not have a stub in typeshed for this test case
    import virtualenv as vv  # type: ignore
    assert 'virtualenv' not in globals()
    # TODO: We shouldn't add local imports to globals()
    # assert 'vv' not in globals()
    assert isinstance(vv.__name__, str)

[file testmodule.py]
def factorial(x: int) -> int:
    if x == 0:
        return 1
    else:
        return x * factorial(x-1)
[file welp.py]
def foo(x: int) -> int:
    return x
[file pkg/__init__.py]
x = 1
[file pkg/mod.py]
y = 2
[file nob.py]
z = 3

[case testImportMissing]
# The unchecked module is configured by the test harness to not be
# picked up by mypy, so we can test that we do that right thing when
# calling library modules without stubs.
import unchecked  # type: ignore
import unchecked as lol  # type: ignore
assert unchecked.x == 10
assert lol.x == 10
[file unchecked.py]
x = 10

[file driver.py]
import native

[case testFromImport]
from testmodule import g

def f(x: int) -> int:
    return g(x)
[file testmodule.py]
def g(x: int) -> int:
    return x + 1
[file driver.py]
from native import f
assert f(1) == 2

[case testFromImportWithUntypedModule]

# avoid including an __init__.py and use type: ignore to test what happens
# if mypy can't tell if mod isn't a module
from pkg import mod # type: ignore

def test_import() -> None:
    assert mod.h(8) == 24

[file pkg/mod.py]
def h(x):
    return x * 3

[case testFromImportWithKnownModule]
from pkg import mod1
from pkg import mod2 as modmod
from pkg.mod2 import g as gg
from pkg.mod3 import h as h2, g as g2

def test_import() -> None:
    assert mod1.h(8) == 24
    assert modmod.g(1) == 1
    assert gg(2) == 2
    assert h2(10) == 12
    assert g2(10) == 13

[file pkg/__init__.py]
[file pkg/mod1.py]
def h(x: int) -> int:
    return x * 3

[file pkg/mod2.py]
def g(x: int) -> int:
    return x

[file pkg/mod3.py]
def h(x: int) -> int:
    return x + 2

def g(x: int) -> int:
    return x + 3

[case testFromImportWithUnKnownModule]
def test_import() -> None:
    try:
        from pkg import a # type: ignore
    except ImportError:
        pass

[file pkg/__init__.py]

[case testMultipleFromImportsWithSamePackageButDifferentModules]
from pkg import a
from pkg import b

def test_import() -> None:
    assert a.g() == 4
    assert b.h() == 39

[file pkg/__init__.py]
[file pkg/a.py]

def g() -> int:
    return 4

[file pkg/b.py]

def h() -> int:
    return 39

[case testReexport]
# Test that we properly handle accessing values that have been reexported
import a
def f(x: int) -> int:
    return a.g(x) + a.foo + a.b.foo

whatever = a.A()

[file a.py]
from b import g as g, A as A, foo as foo
import b

[file b.py]
def g(x: int) -> int:
    return x + 1

class A:
    pass

foo = 20

[file driver.py]
from native import f, whatever
import b

assert f(20) == 61
assert isinstance(whatever, b.A)

[case testAssignModule]
import a
assert a.x == 20
a.x = 10
[file a.py]
x = 20
[file driver.py]
import native