def import_multiple_aliases_using_same_name_resolve_to_same_node():
declarations = _create_declarations(["x"])
first_alias_node = nodes.import_alias("x.y", None)
second_alias_node = nodes.import_alias("x", None)
node = nodes.Import([first_alias_node, second_alias_node])
references = resolve(node, declarations)
assert_is(references.referenced_declaration(first_alias_node), references.referenced_declaration(second_alias_node))
def test_multiple_imported_names_in_one_statement_generates_multiple_assignments(self):
_assert_transform(
nodes.import_from(["."], [
nodes.import_alias("x", None),
nodes.import_alias("y", None),
]),
cc.statements([
cc.assign(cc.ref("x"), cc.attr(cc.module_ref(["."]), "x")),
cc.assign(cc.ref("y"), cc.attr(cc.module_ref(["."]), "y")),
]),
)
def can_parse_import_from_in_current_package_and_many_names():
source = """
from . import message, go
"""
module_node = parser.parse(source)
expected_node = nodes.import_from(["."], [
nodes.import_alias("message", None),
nodes.import_alias("go", None),
])
assert_equal(expected_node, module_node.body[0])
def test_import_multiple_values_in_single_import_statement(self):
_assert_transform(
nodes.import_([
nodes.import_alias("os", None),
nodes.import_alias("sys", None)
]),
cc.statements([
cc.assign(cc.ref("os"), cc.module_ref(["os"])),
cc.assign(cc.ref("sys"), cc.module_ref(["sys"])),
])
)
def error_if_imported_name_is_already_bound_to_different_module():
modules = {
("notes", ): module_type("notes"),
("messages", ): module_type("messages"),
}
statements = [
nodes.Import([nodes.import_alias("notes", "messages")]),
nodes.Import([nodes.import_alias("messages", None)])
]
assert_raises(errors.UnexpectedTargetTypeError, lambda: _update_blank_context(statements, modules))
def can_import_module_after_importing_parent_package():
messages_module = module_type("messages")
hello_module = module_type("messages.hello", [types.attr("value", types.str_type)])
modules = {
("messages", ): messages_module,
("messages", "hello"): hello_module,
}
context = _update_blank_context([
nodes.Import([nodes.import_alias("messages", None)]),
nodes.Import([nodes.import_alias("messages.hello", None)])
], modules)
assert_equal(types.str_type, context.lookup_name("messages").attrs.type_of("hello").attrs.type_of("value"))
assert "hello" not in messages_module.attrs
def import_from_alias_name_is_declared():
alias_node = nodes.import_alias("x", "y")
node = nodes.import_from(["."], [alias_node])
declarations = find_declarations(node)
assert_equal("y", declarations.declaration("y").name)
assert isinstance(declarations.declaration("y"), name_declaration.ImportDeclarationNode)
assert not declarations.is_declared("x")
def value_in_package_can_have_same_name_as_module_if_it_is_that_module():
value_node = nodes.import_from(["."], [nodes.import_alias("x", None)])
node = nodes.module([value_node], is_executable=False)
_check_module(LocalModule("root/__init__.py", node), {
(".",): module({}),
(".", "x"): module({}),
})
def can_parse_import_alias():
source = """
from . import message as m
"""
module_node = parser.parse(source)
expected_node = nodes.import_from(["."], [nodes.import_alias("message", "m")])
assert_equal(expected_node, module_node.body[0])
def error_is_raised_if_import_cannot_be_resolved():
node = nodes.Import([nodes.import_alias("message.value", None)])
try:
_update_blank_context(node, {})
assert False
except errors.ModuleNotFoundError as error:
assert_equal(node, error.node)
def can_parse_import_package():
source = """
import messages
"""
module_node = parser.parse(source)
expected_node = nodes.Import([nodes.import_alias("messages", None)])
assert_equal(expected_node, module_node.body[0])
def can_import_module_using_plain_import_syntax():
node = nodes.Import([nodes.import_alias("message", None)])
context = _update_blank_context(node, {
("message", ): module_type("message", [types.attr("value", types.str_type)])
})
assert_equal(types.str_type, context.lookup_name("message").attrs.type_of("value"))
def can_import_value_from_relative_module_using_import_from_syntax():
node = nodes.import_from([".", "message"], [nodes.import_alias("value", None)])
context = _update_blank_context(node, {
(".", "message"): module_type("message", [types.attr("value", types.str_type)])
})
assert_equal(types.str_type, context.lookup_name("value"))
assert_raises(errors.UnboundLocalError, lambda: context.lookup_name("message"))
def can_import_module_using_import_from_syntax():
node = nodes.import_from(["."], [nodes.import_alias("message", None)])
message_module = module_type("message", [types.attr("value", types.str_type)])
context = _update_blank_context(node, {
(".", "message"): message_module,
})
assert_equal(types.str_type, context.lookup_name("message").attrs.type_of("value"))
def test_importing_module_from_package_references_module_directly(self):
module_resolver = FakeModuleResolver({
(("x", ), "y"): ResolvedImport(["x", "y"], _stub_module, None)
})
_assert_transform(
nodes.import_from(["x"], [nodes.import_alias("y", None)]),
cc.assign(cc.ref("y"), cc.module_ref(["x", "y"])),
module_resolver=module_resolver,
)
def can_use_aliases_with_plain_import_syntax():
node = nodes.Import([nodes.import_alias("message", "m")])
context = _update_blank_context(node, {
("message", ): module_type("message", [types.attr("value", types.str_type)])
})
assert_equal(types.str_type, context.lookup_name("m").attrs.type_of("value"))
assert_raises(errors.UnboundLocalError, lambda: context.lookup_name("message"))
def can_parse_import_from_with_relative_import_of_child_module():
source = """
from .x.y import message
"""
module_node = parser.parse(source)
expected_node = nodes.import_from([".", "x", "y"], [
nodes.import_alias("message", None),
])
assert_equal(expected_node, module_node.body[0])
def test_import_of_module_in_package_assigns_values_for_both_package_and_module(self):
_assert_transform(
nodes.import_([
nodes.import_alias("os.path", None),
]),
cc.statements([
cc.assign(cc.ref("os"), cc.module_ref(["os"])),
cc.assign(cc.attr(cc.ref("os"), "path"), cc.module_ref(["os", "path"])),
])
)
def can_parse_absolute_import_from():
source = """
from x.y import message
"""
module_node = parser.parse(source)
expected_node = nodes.import_from(["x", "y"], [
nodes.import_alias("message", None),
])
assert_equal(expected_node, module_node.body[0])
def error_if_imported_name_is_already_bound_to_non_module_value():
modules = {
("messages", ): module_type("messages"),
}
statements = [
nodes.assign([nodes.ref("messages")], nodes.none()),
nodes.Import([nodes.import_alias("messages", None)])
]
assert_raises(errors.UnexpectedTargetTypeError, lambda: _update_blank_context(statements, modules))
def importing_module_in_package_mutates_that_package_in_importing_module_only():
node = nodes.Import([nodes.import_alias("messages.hello", None)])
messages_module = module_type("messages")
hello_module = module_type("messages.hello", [types.attr("value", types.str_type)])
context = _update_blank_context(node, {
("messages", ): messages_module,
("messages", "hello"): hello_module,
})
assert_equal(types.str_type, context.lookup_name("messages").attrs.type_of("hello").attrs.type_of("value"))
assert "hello" not in messages_module.attrs
def builtin_modules_are_typed():
cgi_module = BuiltinModule("cgi", types.module("cgi", [
types.attr("escape", types.none_type),
]))
node = nodes.Import([nodes.import_alias("cgi", None)])
context = update_blank_context(
node,
module_resolver=FakeModuleResolver({("cgi",): cgi_module}),
module_types=FakeModuleTypes({}),
)
assert_equal(types.none_type, context.lookup_name("cgi").attrs.type_of("escape"))
def import_from_aliases_are_resolved():
declarations = _create_declarations(["x"])
alias_node = nodes.import_alias("x", None)
node = nodes.import_from(["."], [alias_node])
references = resolve(node, declarations)
assert_equal(declarations.declaration("x"), references.referenced_declaration(alias_node))
def test_import_of_module_assigns_module_to_name(self):
_assert_transform(
nodes.import_([nodes.import_alias("message", None)]),
cc.assign(cc.ref("message"), cc.module_ref(["message"]))
)
def import_name_is_definitely_bound_after_import_from_statement():
alias_node = nodes.import_alias("x.y", None)
node = nodes.import_from(["."], [alias_node])
bindings = _updated_bindings(node)
assert_equal(True, bindings.is_definitely_bound(alias_node))
def test_import_of_module_assigns_module_to_as_name_if_present(self):
_assert_transform(
nodes.import_([nodes.import_alias("message", "m")]),
cc.assign(cc.ref("m"), cc.module_ref(["message"]))
)
def test_import_from_assigns_value_to_asname_if_asname_is_set(self):
_assert_transform(
nodes.import_from(["os", "path"], [nodes.import_alias("join", "j")]),
cc.assign(cc.ref("j"), cc.attr(cc.module_ref(["os", "path"]), "join")),
)
def test_import_from_uses_two_dots_to_indicate_import_from_parent_package(self):
_assert_transform(
nodes.import_from([".."], [nodes.import_alias("x", None)]),
cc.assign(cc.ref("x"), cc.attr(cc.module_ref([".."]), "x")),
)
def import_name_is_declared():
alias_node = nodes.import_alias("x.y", None)
node = nodes.Import([alias_node])
declarations = find_declarations(node)
assert_equal("x", declarations.declaration("x").name)
assert isinstance(declarations.declaration("x"), name_declaration.ImportDeclarationNode)
