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)