def find_all_submodule_path(module: types.ModuleType) -> List[str]:
"""
get all submodules path of a module
like "tracim_backend.lib.core.plugin"
see https://stackoverflow.com/a/49023460
:param module: module to check
:return: list of absolute path of module name
"""
module_path_list = []
module_spec_list = []
for importer, submodule_relative_path, is_package in pkgutil.walk_packages(
module.__path__):
submodule_path = "{module_name}.{submodule_relative_path}".format(
module_name=module.__name__,
submodule_relative_path=submodule_relative_path)
if is_package:
spec = pkgutil._get_spec(importer, submodule_relative_path)
importlib._bootstrap._load(spec)
module_spec_list.append(spec)
else:
module_path_list.append(submodule_path)
for spec in module_spec_list:
# INFO - G.M - 2019-11-29 - remove submodule from loaded modules
del sys.modules[spec.name]
return module_path_list
def test_iter_importers(self):
iter_importers = pkgutil.iter_importers
get_importer = pkgutil.get_importer
pkgname = 'spam'
modname = 'eggs'
dirname = self.create_init(pkgname)
pathitem = os.path.join(dirname, pkgname)
fullname = '{}.{}'.format(pkgname, modname)
sys.modules.pop(fullname, None)
sys.modules.pop(pkgname, None)
try:
self.create_submodule(dirname, pkgname, modname, 0)
importlib.import_module(fullname)
importers = list(iter_importers(fullname))
expected_importer = get_importer(pathitem)
for finder in importers:
spec = pkgutil._get_spec(finder, fullname)
loader = spec.loader
try:
loader = loader.loader
except AttributeError:
# For now we still allow raw loaders from
# find_module().
pass
self.assertIsInstance(finder, importlib.machinery.FileFinder)
self.assertEqual(finder, expected_importer)
self.assertIsInstance(loader,
importlib.machinery.SourceFileLoader)
self.assertIsNone(pkgutil._get_spec(finder, pkgname))
with self.assertRaises(ImportError):
list(iter_importers('invalid.module'))
with self.assertRaises(ImportError):
list(iter_importers('.spam'))
finally:
shutil.rmtree(dirname)
del sys.path[0]
try:
del sys.modules['spam']
del sys.modules['spam.eggs']
except KeyError:
pass
def test_iter_importers(self):
iter_importers = pkgutil.iter_importers
get_importer = pkgutil.get_importer
pkgname = 'spam'
modname = 'eggs'
dirname = self.create_init(pkgname)
pathitem = os.path.join(dirname, pkgname)
fullname = '{}.{}'.format(pkgname, modname)
sys.modules.pop(fullname, None)
sys.modules.pop(pkgname, None)
try:
self.create_submodule(dirname, pkgname, modname, 0)
importlib.import_module(fullname)
importers = list(iter_importers(fullname))
expected_importer = get_importer(pathitem)
for finder in importers:
spec = pkgutil._get_spec(finder, fullname)
loader = spec.loader
try:
loader = loader.loader
except AttributeError:
# For now we still allow raw loaders from
# find_module().
pass
self.assertIsInstance(finder, importlib.machinery.FileFinder)
self.assertEqual(finder, expected_importer)
self.assertIsInstance(loader,
importlib.machinery.SourceFileLoader)
self.assertIsNone(pkgutil._get_spec(finder, pkgname))
with self.assertRaises(ImportError):
list(iter_importers('invalid.module'))
with self.assertRaises(ImportError):
list(iter_importers('.spam'))
finally:
shutil.rmtree(dirname)
del sys.path[0]
try:
del sys.modules['spam']
del sys.modules['spam.eggs']
except KeyError:
pass
def find_cogs(package):
"""
Finds all modules in package and presents them in the format
required by :meth:`discord.ext.cli.Bot.load_extension`.
This is useful when you need to load cogs from multiple
areas of your bot. Simply convert your cogs directory
into a package and run this method on it.
Parameters
-----------
package : package
Your cogs directory as a python package.
Returns
--------
list or None
A list of strings of format `foo.bar` as required by
:func: `load_extension`. If package passed is not
valid then `None` is returned instead.
"""
loader = pkgutil.get_loader(package)
if loader is None:
return loader
try:
if not loader.is_package(package.__name__):
return None
except AttributeError:
return None
cog_list = []
spec_list = []
for importer, modname, ispkg in pkgutil.walk_packages(package.__path__):
import_path = f"{package.__name__}.{modname}"
if ispkg:
spec = pkgutil._get_spec(importer, modname)
importlib._bootstrap._load(spec)
spec_list.append(spec)
else:
cog_list.append(import_path)
# remove sys.modules clutter created during cog search
for spec in spec_list:
del sys.modules[spec.name]
return cog_list
def find_generators(module):
path_dict = {}
spec_list = []
for importer, modname, ispkg in pkgutil.walk_packages(module.__path__):
import_path = '{}.{}'.format(module.__name__, modname)
if ispkg:
spec = pkgutil._get_spec(importer, modname)
importlib._bootstrap._load(spec)
spec_list.append(spec)
elif import_path.startswith('urizen.generators'):
path_dict[import_path[18:]] = [
f
for f in getmembers(sys.modules.get(import_path))
if isfunction(f[1]) and not f[0].startswith('_')
and f[1].__module__ == import_path
]
for spec in spec_list:
del sys.modules[spec.name]
return path_dict
def find_abs_modules(package):
path_list = []
spec_list = []
for importer, modname, ispkg in pkgutil.walk_packages(package.__path__):
import_path = f'{package.__name__}.{modname}'
if ispkg:
spec = pkgutil._get_spec(importer, modname)
try:
importlib._bootstrap._load(spec)
spec_list.append(spec)
except Exception as e:
print(
f'Could not load package {modname}, so it will be ignored ({e}).'
)
else:
path_list.append(import_path)
for spec in spec_list:
del sys.modules[spec.name]
return path_list
def find_abs_modules(MOD_NAME, MOD_DIR):
import importlib
import pkgutil
path_list = [MOD_NAME]
spec_list = []
for importer, modname, ispkg in pkgutil.walk_packages([MOD_DIR]):
import_path = "{modname}".format(MOD_NAME=MOD_NAME, modname=modname)
if ispkg:
spec = pkgutil._get_spec(importer, modname)
importlib._bootstrap._load(spec)
spec_list.append(spec)
else:
if modname.startswith("_"):
# avoid private modules
continue
path_list.append(import_path)
for spec in spec_list:
del sys.modules[spec.name]
return path_list
def _get_coverage(package_name, importer, modname, ispkg, ignores):
"""
Args:
importer:
modname:
ispkg:
ignores [pathlib.Path]:
Returns:
"""
importer_path = pathlib.Path(importer.path)
for ignore in ignores:
if importer_path.samefile(ignore):
return
if str(pathlib.Path(importer.path).resolve()).startswith(str(ignore)):
return
if ispkg and (importer_path / modname.split('.')[-1]).samefile(ignore):
return
try:
if ispkg:
spec = pkgutil._get_spec(importer, modname)
object = importlib._bootstrap._load(spec)
else:
import_path = f"{package_name}.{modname}"
object = importlib.import_module(import_path)
counter = count_module(object)
return counter
except ImportError as e:
logger.error(f"Failed to import {modname}: {e}")
return
except Exception as e:
logger.error(f"Failed to parse: {modname}: {e}")
return
def update_event(self, inp=-1):
self.set_output_val(0, pkgutil._get_spec(self.input(0), self.input(1)))
