def test_load_any(self):
# import an already-imported module
self.assertIdentical(modules.load_any('snakeoil.modules'), modules)
# attribute of an already imported module
self.assertIdentical(modules.load_any('sys.path'), sys.path)
# already imported toplevel.
self.assertIdentical(sys, modules.load_any('sys'))
# unimported
myfoo = modules.load_any('mod_testpack.mod_test2.foo')
# "Unable to import"
# pylint: disable=F0401
from mod_testpack.mod_test2 import foo
self.assertIdentical(foo, myfoo)
# nonexisting attribute
self.assertRaises(
modules.FailedImport, modules.load_any, 'snakeoil.froznicator')
# nonexisting top-level
self.assertRaises(
modules.FailedImport, modules.load_any,
'spork_does_not_exist.foo')
self.assertRaises(
modules.FailedImport, modules.load_any,
'spork_does_not_exist')
# not imported yet
self.assertRaises(
modules.FailedImport,
modules.load_any, 'mod_testpack.mod_test3')
def _process_plugin(package, plug, filter_disabled=False):
if isinstance(plug.target, str):
plug = modules.load_any(plug.target)
elif isinstance(plug.target, int):
module = modules.load_any(plug.source)
plugs = getattr(module, PLUGIN_ATTR, {})
plugs = plugs.get(plug.key, [])
if len(plugs) <= plug.target:
logger.exception(
"plugin cache for %s, %s, %s is somehow wrong; no item at position %s",
package.__name__, plug.source, plug.key, plug.target)
return None
plug = plugs[plug.target]
else:
logger.error("package %s, plug %s; non int, non string. wtf?",
package.__name__, plug)
return None
if filter_disabled:
if getattr(plug, 'disabled', False):
logger.debug("plugin %s is disabled, skipping", plug)
return None
f = getattr(plug, '_plugin_disabled_check', None)
if f is not None and f():
logger.debug("plugin %s is disabled, skipping", plug)
return None
return plug
def test_load_any(self):
# import an already-imported module
self.assertIdentical(modules.load_any('snakeoil.modules'), modules)
# attribute of an already imported module
self.assertIdentical(modules.load_any('sys.path'), sys.path)
# already imported toplevel.
self.assertIdentical(sys, modules.load_any('sys'))
# unimported
myfoo = modules.load_any('mod_testpack.mod_test2.foo')
# "Unable to import"
# pylint: disable=F0401
from mod_testpack.mod_test2 import foo
self.assertIdentical(foo, myfoo)
# nonexisting attribute
self.assertRaises(modules.FailedImport, modules.load_any,
'snakeoil.froznicator')
# nonexisting top-level
self.assertRaises(modules.FailedImport, modules.load_any,
'spork_does_not_exist.foo')
self.assertRaises(modules.FailedImport, modules.load_any,
'spork_does_not_exist')
# not imported yet
self.assertRaises(modules.FailedImport, modules.load_any,
'mod_testpack.mod_test3')
def _process_plugin(package, plug, filter_disabled=False):
if isinstance(plug.target, basestring):
try:
plug = modules.load_any(plug.target)
except modules.FailedImport, e:
logger.exception("plugin import for %s failed processing file %s, entry %s: %s",
package.__name__, plug.source, plug.target, e)
return None
def _process_plugin(package, plug, filter_disabled=False):
if isinstance(plug.target, basestring):
try:
plug = modules.load_any(plug.target)
except modules.FailedImport as e:
logger.exception(
"plugin import for %s failed processing file %s, entry %s: %s",
package.__name__,
plug.source,
plug.target,
e,
)
return None
elif isinstance(plug.target, int):
try:
module = modules.load_any(plug.source)
except modules.FailedImport as e:
logger.exception("plugin import for %s failed processing file %s: %s", package.__name__, plug.source, e)
return None
plugs = getattr(module, PLUGIN_ATTR, {})
plugs = plugs.get(plug.key, [])
if len(plugs) <= plug.target:
logger.exception(
"plugin cache for %s, %s, %s is somehow wrong; no item at position %s",
package.__name__,
plug.source,
plug.key,
plug.target,
)
return None
plug = plugs[plug.target]
else:
logger.error("package %s, plug %s; non int, non string. wtf?", package.__name__, plug)
return None
if filter_disabled:
if getattr(plug, "disabled", False):
logger.debug("plugin %s is disabled, skipping", plug)
return None
f = getattr(plug, "_plugin_disabled_check", None)
if f is not None and f():
logger.debug("plugin %s is disabled, skipping", plug)
return None
return plug
def python_namespace_type(value, module=False, attribute=False):
"""
return the object from python namespace that value specifies
:param value: python namespace, snakeoil.modules for example
:param module: if true, the object must be a module
:param attribute: if true, the object must be a non-module
:raises ValueError: if the conditions aren't met, or import fails
"""
try:
if module:
return import_module(value)
elif attribute:
return modules.load_attribute(value)
return modules.load_any(value)
except (ImportError, modules.FailedImport) as err:
compatibility.raise_from(argparse.ArgumentTypeError(str(err)))
def python_namespace_type(value, module=False, attribute=False):
"""
return the object from python namespace that value specifies
:param value: python namespace, snakeoil.modules for example
:param module: if true, the object must be a module
:param attribute: if true, the object must be a non-module
:raises ValueError: if the conditions aren't met, or import fails
"""
try:
if module:
return import_module(value)
elif attribute:
return modules.load_attribute(value)
return modules.load_any(value)
except (ImportError, modules.FailedImport) as err:
compatibility.raise_from(argparse.ArgumentTypeError(str(err)))
def disabled_demandload(scope, *imports):
"""Exactly like :py:func:`demandload` but does all imports immediately."""
for source, target in parse_imports(imports):
scope[target] = load_any(source)
def _replace_func(self):
source = object.__getattribute__(self, '_source')
return load_any(source)
for plug in sequence:
plug = _process_plugin(package, plug, filter_disabled)
if plug is not None:
yield plug
def _process_plugin(package, plug, filter_disabled=False):
if isinstance(plug.target, basestring):
try:
plug = modules.load_any(plug.target)
except modules.FailedImport, e:
logger.exception("plugin import for %s failed processing file %s, entry %s: %s",
package.__name__, plug.source, plug.target, e)
return None
elif isinstance(plug.target, int):
try:
module = modules.load_any(plug.source)
except modules.FailedImport, e:
logger.exception("plugin import for %s failed processing file %s: %s",
package.__name__, plug.source, e)
return None
plugs = getattr(module, PLUGIN_ATTR, {})
plugs = plugs.get(plug.key, [])
if len(plugs) <= plug.target:
logger.exception("plugin cache for %s, %s, %s is somehow wrong; no item at position %s",
package.__name__, plug.source, plug.key, plug.target)
return None
plug = plugs[plug.target]
else:
logger.error("package %s, plug %s; non int, non string. wtf?",
package.__name__, plug)
return None
def disabled_demandload(scope, *imports):
"""Exactly like :py:func:`demandload` but does all imports immediately."""
for source, target in parse_imports(imports):
scope[target] = load_any(source)
def test_load_any(self):
# import an already-imported module
assert modules.load_any('snakeoil.modules') is modules
# attribute of an already imported module
assert modules.load_any('sys.path') is sys.path
# already imported toplevel.
assert sys is modules.load_any('sys')
# unimported
myfoo = modules.load_any('mod_testpack.mod_test2.foo')
# "Unable to import"
# pylint: disable=F0401
from mod_testpack.mod_test2 import foo
assert foo is myfoo
# nonexisting attribute
with pytest.raises(modules.FailedImport):
modules.load_any('snakeoil.froznicator')
# nonexisting top-level
with pytest.raises(modules.FailedImport):
modules.load_any('spork_does_not_exist.foo')
with pytest.raises(modules.FailedImport):
modules.load_any('spork_does_not_exist')
# not imported yet
with pytest.raises(modules.FailedImport):
modules.load_any('mod_testpack.mod_test3')
def disabled_demandload(*imports, **kwargs):
"""Exactly like :py:func:`demandload` but does all imports immediately."""
scope = kwargs.pop('scope', sys._getframe(1).f_globals)
for source, target in parse_imports(imports):
scope[target] = load_any(source)
def test_load_any(self):
# import an already-imported module
assert modules.load_any('snakeoil.modules') is modules
# attribute of an already imported module
assert modules.load_any('sys.path') is sys.path
# already imported toplevel.
assert sys is modules.load_any('sys')
# unimported
myfoo = modules.load_any('mod_testpack.mod_test2.foo')
# "Unable to import"
# pylint: disable=F0401
from mod_testpack.mod_test2 import foo
assert foo is myfoo
# nonexisting attribute
with pytest.raises(modules.FailedImport):
modules.load_any('snakeoil.froznicator')
# nonexisting top-level
with pytest.raises(modules.FailedImport):
modules.load_any('spork_does_not_exist.foo')
with pytest.raises(modules.FailedImport):
modules.load_any('spork_does_not_exist')
# not imported yet
with pytest.raises(modules.FailedImport):
modules.load_any('mod_testpack.mod_test3')
