def test_not_package(self):
d = join(FILES_DIR, 'python3')
path = join(d, 'c.py')
resolver = ModuleNameResolver([d])
mod, package = resolver.resolve(path)
self.assertEqual('c', mod)
self.assertNone(package)
def test_find_module(self):
resolver = ModuleNameResolver(sys.path)
pathname, kind = resolver._find_module('modipyd.resolve', sys.path)
self.assert_(kind in (imp.PY_SOURCE, imp.PY_COMPILED))
path = abspath(join(dirname(__file__), '..', 'modipyd', 'resolve.py'))
self.assertEqual(path, pathname)
self.assertRaises(ImportError, resolver._find_module, 'modipyd.xxx', sys.path)
def test_name_collision(self):
directory = join(FILES_DIR, 'name_collision')
resolver = ModuleNameResolver(directory)
# The package 'test' precedes 'test.py'
path = join(directory, 'test', '__init__.py')
modname, package = resolver.resolve(path)
self.assertEqual('test', modname)
self.assertEqual('test', package)
path = join(directory, 'test.py')
self.assert_(os.path.exists(path))
self.assertRaises(ImportError, resolver.resolve, path)
def read_module_code(filename, typebits=None, search_path=None,
resolver=None,
allow_compilation_failure=False,
allow_standalone=False):
"""
Read python module file, and return ``ModuleCode`` instance.
If *typebits* argument is not ``None``, *filename* must be
filepath without file extention.
If *typebits* argument is ``None``, it is detected by filename.
"""
if typebits is None:
filename, _, typebits = module_file_typebits(filename)
if resolver is None:
resolver = ModuleNameResolver(search_path)
code = None
try:
# Since editing .py files will not affect .pyc and .pyo files soon,
# give priority to .py files.
if typebits & PYTHON_SOURCE_MASK:
# .py
sourcepath = filename + '.py'
code = compile_source(sourcepath)
elif typebits & (PYTHON_OPTIMIZED_MASK | PYTHON_COMPILED_MASK):
# .pyc, .pyo
if typebits & PYTHON_OPTIMIZED_MASK:
sourcepath = filename + '.pyo'
else:
sourcepath = filename + '.pyc'
code = load_compiled(sourcepath)
else:
assert False, "illegal typebits: %d" % typebits
except (SyntaxError, ImportError):
LOGGER.warn(
"Exception occurred while loading compiled bytecode",
exc_info=True)
if not allow_compilation_failure:
raise
try:
module_name, package_name = resolver.resolve(sourcepath)
except ImportError:
if not allow_standalone:
raise
module_name = filepath_to_identifier(sourcepath)
package_name = None
return ModuleCode(module_name, package_name, sourcepath, code)
def test_package_name(self):
d = join(FILES_DIR, 'imports')
d = abspath(d)
resolver = ModuleNameResolver([d])
for f in utils.collect_files(d):
assert f.startswith(d)
if not f.endswith('.py'):
continue
modname, package = resolver.resolve(f)
f = f[len(d):]
if f[0] == '/':
f = f[1:]
f = splitext(f)[0]
f = f.replace('/', '.')
if f.endswith('.__init__'):
f = utils.split_module_name(f)[0]
self.assertEqual(f, modname)
self.assertEqual(f, package)
else:
self.assertEqual(f, modname)
self.assertEqual(
utils.split_module_name(f)[0], package)
