def test_dotted_comma(self):
self.assertEqual(self.parse("""
import a.b, c
"""), [
parsepy.ImportStatement(name='a.b'),
parsepy.ImportStatement(name='c')
])
def test_multiple_2(self):
self.assertEqual(self.parse("""
import a, b as bb
"""), [
parsepy.ImportStatement(name='a'),
parsepy.ImportStatement(name='b', new_name='bb')
])
def test_multiple_1(self):
self.assertEqual(self.parse("""
import a, b, c, d
"""), [
parsepy.ImportStatement(name='a'),
parsepy.ImportStatement(name='b'),
parsepy.ImportStatement(name='c'),
parsepy.ImportStatement(name='d')
])
def test_dot_multiple(self):
self.assertEqual(
self.parse("""
from . import a, b, c as cc
"""), [
parsepy.ImportStatement(name='.a', new_name='a', is_from=True),
parsepy.ImportStatement(name='.b', new_name='b', is_from=True),
parsepy.ImportStatement(name='.c', new_name='cc', is_from=True)
])
def test_multiple_3(self):
self.assertEqual(
self.parse("""
import a, b as bb, a.x, a.x.y as a_x_y
"""), [
parsepy.ImportStatement(name='a'),
parsepy.ImportStatement(name='b', new_name='bb'),
parsepy.ImportStatement(name='a.x', new_name='a.x'),
parsepy.ImportStatement(name='a.x.y', new_name='a_x_y'),
])
def test_from_multiple(self):
self.assertEqual(
self.parse("""
from a import b, c, d as dd
"""), [
parsepy.ImportStatement(name='a.b', new_name='b',
is_from=True),
parsepy.ImportStatement(name='a.c', new_name='c',
is_from=True),
parsepy.ImportStatement(
name='a.d', new_name='dd', is_from=True)
])
def test_print_function(self):
self.assertEqual(
self.parse("""
from __future__ import print_function
import sys
print("hello world", file=sys.stdout)
"""), [
parsepy.ImportStatement(name='__future__.print_function',
new_name='print_function',
is_from=True),
parsepy.ImportStatement(name='sys')
])
def test_from_parentheses(self):
self.assertEqual(
self.parse("""
from a import (b, c, d as dd)
"""), [
parsepy.ImportStatement(name='a.b', new_name='b',
is_from=True),
parsepy.ImportStatement(name='a.c', new_name='c',
is_from=True),
parsepy.ImportStatement(
name='a.d', new_name='dd', is_from=True)
])
def test_asterisk(self):
self.assertEqual(
self.parse("""
from a import *
from a.b import *
from a . b . c import *
"""), [
parsepy.ImportStatement(name='a', is_from=True, is_star=True),
parsepy.ImportStatement(name='a.b', is_from=True,
is_star=True),
parsepy.ImportStatement(
name='a.b.c', is_from=True, is_star=True)
])
def testResolveParentPackageFileWithModule(self):
imp = parsepy.ImportStatement("..a")
r = self.make_resolver("foo/d.py", "bar.foo.d")
f = r.resolve_import(imp)
self.assertEqual(f.path, "a.py")
self.assertTrue(isinstance(f, resolve.Local))
self.assertEqual(f.module_name, "bar.a")
def test_encoding_latin1(self):
self.assertEqual(
self.parse("""
# -*- coding: iso-8859-1 -*-
# Author: Thomas Sch\xf6n
import a
"""), [parsepy.ImportStatement(name='a')])
def test_encoding_utf8(self):
self.assertEqual(
self.parse("""
# -*- coding: utf-8 -*-
# Author: Lo\x6f\xc3\xafc Fooman
import a
"""), [parsepy.ImportStatement(name='a')])
def test_dot(self):
self.assertEqual(
self.parse("""
from . import a
from .a import b
from .a.b import c
from .a.b.c import *
"""), [
parsepy.ImportStatement(name='.a', new_name='a', is_from=True),
parsepy.ImportStatement(
name='.a.b', new_name='b', is_from=True),
parsepy.ImportStatement(
name='.a.b.c', new_name='c', is_from=True),
parsepy.ImportStatement(
name='.a.b.c', is_from=True, is_star=True)
])
def testResolveStarImportSystem(self):
imp = parsepy.ImportStatement("f", is_from=True, is_star=True,
source="/system/f.py")
r = self.make_resolver("x.py", "x")
f = r.resolve_import(imp)
self.assertEqual(f.path, "/system/f.py")
self.assertEqual(f.module_name, "f")
def testResolveStarImport(self):
# from foo.c import *
imp = parsepy.ImportStatement("foo.c", is_from=True, is_star=True)
r = self.make_resolver("x.py", "x")
f = r.resolve_import(imp)
self.assertEqual(f.path, "foo/c.py")
self.assertEqual(f.module_name, "foo.c")
def testResolveStarImportBuiltin(self):
imp = parsepy.ImportStatement("sys", is_from=True, is_star=True)
r = self.make_resolver("x.py", "x")
f = r.resolve_import(imp)
self.assertTrue(isinstance(f, resolve.Builtin))
self.assertEqual(f.path, "sys.so")
self.assertEqual(f.module_name, "sys")
def testFallBackToSource(self):
imp = parsepy.ImportStatement("f", source="/system/f.py")
r = self.make_resolver("x.py", "x")
f = r.resolve_import(imp)
self.assertTrue(isinstance(f, resolve.System))
self.assertEqual(f.path, "/system/f.py")
self.assertEqual(f.module_name, "f")
def testResolveInitFileRelative(self):
imp = parsepy.ImportStatement("..baz")
r = self.make_resolver("foo/d.py", "foo.d")
f = r.resolve_import(imp)
self.assertTrue(isinstance(f, resolve.Local))
self.assertEqual(f.path, "baz/__init__.py")
self.assertEqual(f.module_name, "..baz")
def testResolvePyiFile(self):
imp = parsepy.ImportStatement("x")
r = self.make_resolver("b.py", "b")
f = r.resolve_import(imp)
self.assertTrue(isinstance(f, resolve.Local))
self.assertEqual(f.fs, self.pyi_fs)
self.assertEqual(f.path, "x.pyi")
self.assertEqual(f.module_name, "x")
def testResolveSystemSymbol(self):
imp = parsepy.ImportStatement("argparse.ArgumentParser",
source="/system/argparse.pyc",
is_from=True)
r = self.make_resolver("x.py", "x")
f = r.resolve_import(imp)
self.assertTrue(isinstance(f, resolve.System))
self.assertEqual(f.module_name, "argparse")
def testResolveRelativeFromInitFileWithModule(self):
parent = resolve.Direct("baz/__init__.py", "baz")
imp = parsepy.ImportStatement(".f")
r = resolve.Resolver(self.path, parent)
f = r.resolve_import(imp)
self.assertTrue(isinstance(f, resolve.Local))
self.assertEqual(f.path, "baz/f.py")
self.assertEqual(f.module_name, "baz.f")
def testResolveWithFilesystem(self):
imp = parsepy.ImportStatement("a")
r = self.make_resolver("b.py", "b")
f = r.resolve_import(imp)
self.assertTrue(isinstance(f, resolve.Local))
self.assertEqual(f.fs, self.py_fs)
self.assertEqual(f.path, "a.py")
self.assertEqual(f.module_name, "a")
def test_dotted_from(self):
self.assertEqual(
self.parse("""
from a.b.c import d as e
"""), [
parsepy.ImportStatement(
name='a.b.c.d', new_name='e', is_from=True)
])
def testResolveRelativeSymbol(self):
# importing the Symbol object from baz/__init__.py while in baz/f.py
parent = resolve.Direct("baz/f.py", "baz.f")
imp = parsepy.ImportStatement(".Symbol", is_from=True)
r = resolve.Resolver(self.path, parent)
f = r.resolve_import(imp)
self.assertTrue(isinstance(f, resolve.Local))
self.assertEqual(f.path, "baz/__init__.py")
self.assertEqual(f.module_name, "baz")
def testResolveSystemSymbolNameClash(self):
# from foo.foo import foo
imp = parsepy.ImportStatement("foo.foo.foo",
source="/system/bar/foo/foo.pyc",
is_from=True)
r = self.make_resolver("x.py", "x")
f = r.resolve_import(imp)
self.assertTrue(isinstance(f, resolve.System))
self.assertEqual(f.module_name, "foo.foo")
def testResolveSystemFileNameClash(self):
# `import a` in a.py should get the system a.py
sys_file = "/system/a.py"
imp = parsepy.ImportStatement("a", source=sys_file)
r = self.make_resolver("a.py", "a")
f = r.resolve_import(imp)
self.assertTrue(isinstance(f, resolve.System))
self.assertEqual(f.path, sys_file)
self.assertEqual(f.module_name, "a")
def testResolveSystemInitFile(self):
# from foo.foo import foo
imp = parsepy.ImportStatement("foo.bar.X",
source="/system/foo/bar/__init__.pyc",
is_from=True)
r = self.make_resolver("x.py", "x")
f = r.resolve_import(imp)
self.assertTrue(isinstance(f, resolve.System))
self.assertEqual(f.module_name, "foo.bar")
def testResolveSystemPackageDir(self):
with utils.Tempdir() as d:
py_file = d.create_file("foo/__init__.py")
imp = parsepy.ImportStatement("foo", source=d["foo"], is_from=True)
r = self.make_resolver("x.py", "x")
f = r.resolve_import(imp)
self.assertTrue(isinstance(f, resolve.System))
self.assertEqual(f.module_name, "foo")
self.assertEqual(f.path, py_file)
def testResolveSiblingPackageFile(self):
# This is an invalid import, since we are trying to resolve a relative
# import beyond the top-level package. The file resolver does not figure
# out that we are moving beyond the top-level, but the module name does
# not get qualified and remains relative.
imp = parsepy.ImportStatement("..bar.e")
r = self.make_resolver("foo/d.py", "foo.d")
f = r.resolve_import(imp)
self.assertEqual(f.path, "bar/e.py")
self.assertEqual(f.module_name, "..bar.e")
def testGetPyFromPycSource(self):
# Override a source pyc file with the corresponding py file if it exists
# in the native filesystem.
with utils.Tempdir() as d:
py_file = d.create_file("f.py")
pyc_file = d.create_file("f.pyc")
imp = parsepy.ImportStatement("f", source=pyc_file)
r = self.make_resolver("x.py", "x")
f = r.resolve_import(imp)
self.assertEqual(f.path, py_file)
self.assertEqual(f.module_name, "f")
