96 lines
3.0 KiB
Python
96 lines
3.0 KiB
Python
# (c) 2005 Ian Bicking and contributors; written for Paste (http://pythonpaste.org)
|
|
# Licensed under the MIT license: http://www.opensource.org/licenses/mit-license.php
|
|
|
|
"""
|
|
'imports' a string -- converts a string to a Python object, importing
|
|
any necessary modules and evaluating the expression. Everything
|
|
before the : in an import expression is the module path; everything
|
|
after is an expression to be evaluated in the namespace of that
|
|
module.
|
|
|
|
Alternately, if no : is present, then import the modules and get the
|
|
attributes as necessary. Arbitrary expressions are not allowed in
|
|
that case.
|
|
"""
|
|
|
|
def eval_import(s):
|
|
"""
|
|
Import a module, or import an object from a module.
|
|
|
|
A module name like ``foo.bar:baz()`` can be used, where
|
|
``foo.bar`` is the module, and ``baz()`` is an expression
|
|
evaluated in the context of that module. Note this is not safe on
|
|
arbitrary strings because of the eval.
|
|
"""
|
|
if ':' not in s:
|
|
return simple_import(s)
|
|
module_name, expr = s.split(':', 1)
|
|
module = import_module(module_name)
|
|
obj = eval(expr, module.__dict__)
|
|
return obj
|
|
|
|
def simple_import(s):
|
|
"""
|
|
Import a module, or import an object from a module.
|
|
|
|
A name like ``foo.bar.baz`` can be a module ``foo.bar.baz`` or a
|
|
module ``foo.bar`` with an object ``baz`` in it, or a module
|
|
``foo`` with an object ``bar`` with an attribute ``baz``.
|
|
"""
|
|
parts = s.split('.')
|
|
module = import_module(parts[0])
|
|
name = parts[0]
|
|
parts = parts[1:]
|
|
last_import_error = None
|
|
while parts:
|
|
name += '.' + parts[0]
|
|
try:
|
|
module = import_module(name)
|
|
parts = parts[1:]
|
|
except ImportError as e:
|
|
last_import_error = e
|
|
break
|
|
obj = module
|
|
while parts:
|
|
try:
|
|
obj = getattr(module, parts[0])
|
|
except AttributeError:
|
|
raise ImportError(
|
|
"Cannot find %s in module %r (stopped importing modules with error %s)" % (parts[0], module, last_import_error))
|
|
parts = parts[1:]
|
|
return obj
|
|
|
|
def import_module(s):
|
|
"""
|
|
Import a module.
|
|
"""
|
|
mod = __import__(s)
|
|
parts = s.split('.')
|
|
for part in parts[1:]:
|
|
mod = getattr(mod, part)
|
|
return mod
|
|
|
|
def try_import_module(module_name):
|
|
"""
|
|
Imports a module, but catches import errors. Only catches errors
|
|
when that module doesn't exist; if that module itself has an
|
|
import error it will still get raised. Returns None if the module
|
|
doesn't exist.
|
|
"""
|
|
try:
|
|
return import_module(module_name)
|
|
except ImportError as e:
|
|
if not getattr(e, 'args', None):
|
|
raise
|
|
desc = e.args[0]
|
|
if not desc.startswith('No module named '):
|
|
raise
|
|
desc = desc[len('No module named '):]
|
|
# If you import foo.bar.baz, the bad import could be any
|
|
# of foo.bar.baz, bar.baz, or baz; we'll test them all:
|
|
parts = module_name.split('.')
|
|
for i in range(len(parts)):
|
|
if desc == '.'.join(parts[i:]):
|
|
return None
|
|
raise
|