Python SourceFileLoader.load_module方法代码示例

# 需要导入模块: from importlib.machinery import SourceFileLoader [as 别名]
# 或者: from importlib.machinery.SourceFileLoader import load_module [as 别名]
def load_race(name):
    ensure_directories()
    base_name = name.lower()
    file_name = base_name.replace('-', '_') + ".py"
    class_name = ''.join(part.capitalize() for part in base_name.split('-'))

    try:
        # from this library
        Race = getattr(__import__("dndraces"), class_name)
    except AttributeError:
        # Don't make __pycache__ file in the races directories
        sys.dont_write_bytecode = True
        try:
            # from $HOME
            loader = SourceFileLoader(class_name,
                                      os.path.join(HOME_RACES, file_name))
            races = loader.load_module()
            Race = getattr(races, class_name)
        except FileNotFoundError:
            try:
                # from /etc
                loader = SourceFileLoader(class_name,
                                          os.path.join(ETC_RACES, file_name))
                races = loader.load_module()
                Race = getattr(races, class_name)
            except FileNotFoundError:
                msg = "Can not find class for " + name + "\n"
                msg += 'Looking for class "' + class_name + '" in ' + file_name
                raise FileNotFoundError()

    return Race

# 需要导入模块: from importlib.machinery import SourceFileLoader [as 别名]
# 或者: from importlib.machinery.SourceFileLoader import load_module [as 别名]
def test_all_imports_py():
   """ Tests: test_all_imports_py: for syntax correctness and internal imports
   """
   print('::: TEST: test_all_imports_py()')
   all_modules_path = []
   for root, dirnames, filenames in os_walk(ROOT_PACKAGE_PATH):
      all_modules_path.extend(glob(root + '/*.py'))
   for py_module_file_path in all_modules_path:
      module_filename = path_basename(py_module_file_path)
      module_filename_no_ext = path_splitext(module_filename)[0]

      py_loader = SourceFileLoader(module_filename_no_ext, py_module_file_path)
      py_loader.load_module(module_filename_no_ext)

# 需要导入模块: from importlib.machinery import SourceFileLoader [as 别名]
# 或者: from importlib.machinery.SourceFileLoader import load_module [as 别名]
 def _import_plugin_from_path(self, name, path):
     try:
         mname = "hyperspyui.plugins." + name
         if sys.version_info >= (3, 5):
             import importlib.util
             spec = importlib.util.spec_from_file_location(mname, path)
             module = importlib.util.module_from_spec(spec)
             spec.loader.exec_module(module)
         else:
             from importlib.machinery import SourceFileLoader
             loader = SourceFileLoader(mname, path)
             loader.load_module()
     except Exception:
         self.warn("import", path)

# 需要导入模块: from importlib.machinery import SourceFileLoader [as 别名]
# 或者: from importlib.machinery.SourceFileLoader import load_module [as 别名]
def get_config(name, abspath):
    config = None
    files = os.listdir(abspath)
    if (name + '.yml') in files or (name + '.yaml') in files:
        cfile = name + '.yml'
        cfile = cfile if cfile in files else name + '.yaml'
        with open(os.path.join(abspath, cfile)) as f:
            config = yaml.load(f)
        logger.debug('used yaml')
    else:
        pyloader = SourceFileLoader(name, os.path.join(abspath, name + '.py'))
        pyloader.load_module()
        mod = sys.modules[name]
        config = getattr(mod, name)
        logger.debug('used dict')
    return config

# 需要导入模块: from importlib.machinery import SourceFileLoader [as 别名]
# 或者: from importlib.machinery.SourceFileLoader import load_module [as 别名]
def load_settings(cfg_path=None):
    """todo: Docstring for load_settings

    :param cfg_path: arg description
    :type cfg_path: type description
    :return:
    :rtype:
    """

    global settings

    cfg_path = cfg_path or _config['cfg_path']

    cfg_d = _config.copy()

    if os.path.exists(cfg_path):
        sfl = SourceFileLoader('upkg_cfg', cfg_path)
        cfg_mod = sfl.load_module()

        for m in inspect.getmembers(cfg_mod):
            if m[0][0] != '_':
                cfg_d[m[0]] = m[1]
        # end for m in inspect.getme

    # Make the paths absolute.
    cfg_d["cfg_path"] = _clean_path(cfg_d["cfg_path"])
    cfg_d["upkg_destdir"] = _clean_path(cfg_d["upkg_destdir"])

    settings = Namespace(**cfg_d)

# 需要导入模块: from importlib.machinery import SourceFileLoader [as 别名]
# 或者: from importlib.machinery.SourceFileLoader import load_module [as 别名]
def get_info_from_module(target):
    """Load the module/package, get its docstring and __version__
    """
    log.debug("Loading module %s", target.file)
    sl = SourceFileLoader(target.name, str(target.file))
    with _module_load_ctx():
        m = sl.load_module()
    docstring = m.__dict__.get('__doc__', None)
    if not docstring: 
        raise NoDocstringError('Cannot package module without docstring. '
                                'Please add a docstring to your module.')
    module_version = m.__dict__.get('__version__', None)
    if not module_version: 
        raise NoVersionError('Cannot package module without a version string. '
                             'Please define a `__version__="x.y.z"` in your module.')
    if not isinstance(module_version, str):
        raise InvalidVersion('__version__ must be a string, not {}.'
                                .format(type(module_version)))
    if not module_version[0].isdigit():
        raise InvalidVersion('__version__ must start with a number. It is {!r}.'
                                .format(module_version))

    docstring_lines = docstring.lstrip().splitlines()
    return {'summary': docstring_lines[0],
            'version': m.__version__}

# 需要导入模块: from importlib.machinery import SourceFileLoader [as 别名]
# 或者: from importlib.machinery.SourceFileLoader import load_module [as 别名]
def loadPlugins():
	modules = getPythonScriptModules()
	print("Found python modules to scan for relink lookup %s" % len(modules))
	# print("Modules:")
	# modules.sort()
	# for module in modules:
	# 	print('	', module)
	ret = {}

	for fPath, modName in modules:
		# print("Loading", fPath, modName)
		try:
			loader = SourceFileLoader(modName, fPath)
			mod = loader.load_module()
			plugClasses = findPluginClass(mod, 'Scrape')
			for key, pClass in plugClasses:
				if key in ret:
					raise ValueError("Two plugins providing an interface with the same name? Name: '%s'" % key)
				ret[key] = pClass
		except AttributeError:
			print("Attribute error!", modName)
			traceback.print_exc()
			pass
		except ImportError:
			print("Import error!", modName)
			traceback.print_exc()
			pass
	return ret

# 需要导入模块: from importlib.machinery import SourceFileLoader [as 别名]
# 或者: from importlib.machinery.SourceFileLoader import load_module [as 别名]
 def load_module_from_file(name, path):
     try:
         loaded = SourceFileLoader(name, path)
         if isinstance(loaded, types.ModuleType):
             return loaded, None
         return loaded.load_module(), None
     except Exception as error:
         return None, error

# 需要导入模块: from importlib.machinery import SourceFileLoader [as 别名]
# 或者: from importlib.machinery.SourceFileLoader import load_module [as 别名]
 def load_provider(self, manage_py):
     from plainbox import provider_manager
     from providerbackend import fake_provider_manager
     provider_manager.setup = fake_provider_manager.setup
     loader = SourceFileLoader('manage', manage_py)
     loader.load_module()
     if len(fake_provider_manager.all_setup_kwargs) == 0:
         raise ValueError("provider not defined")
     kwargs = fake_provider_manager.all_setup_kwargs.pop()
     location = os.path.dirname(os.path.abspath(manage_py))
     definition = Provider1Definition()
     definition.location = location
     definition.name = kwargs.get('name', None)
     definition.version = kwargs.get('version', None)
     definition.description = kwargs.get('description', None)
     definition.gettext_domain = kwargs.get('gettext_domain', Unset)
     return Provider1.from_definition(definition, secure=False)

# 需要导入模块: from importlib.machinery import SourceFileLoader [as 别名]
# 或者: from importlib.machinery.SourceFileLoader import load_module [as 别名]
    def return_module(self, name='test'):
        file_name = path.join(self.out_dir.name, name + '.py')

        sys_path.append(self.out_dir.name)
        loader = SourceFileLoader(self._testMethodName, file_name)
        module = loader.load_module(self._testMethodName)
        sys_path.remove(self.out_dir.name)

        return module

# 需要导入模块: from importlib.machinery import SourceFileLoader [as 别名]
# 或者: from importlib.machinery.SourceFileLoader import load_module [as 别名]
def load_module_by_path(fpath, module_name=None):
    if module_name is None:
        module_name = str(uuid())
    fpath = os.path.realpath(fpath)
    if os.path.isdir(fpath):
        fpath = os.path.join(fpath, '__init__.py')
    loader = SourceFileLoader(module_name, fpath)
    m = loader.load_module()
    return m

# 需要导入模块: from importlib.machinery import SourceFileLoader [as 别名]
# 或者: from importlib.machinery.SourceFileLoader import load_module [as 别名]
        def load_doc_manager(path):
            name, _ = os.path.splitext(os.path.basename(path))
            try:
                from importlib.machinery import SourceFileLoader

                loader = SourceFileLoader(name, path)
                module = loader.load_module(name)
            except ImportError:
                module = imp.load_source(name, path)
            return module

# 需要导入模块: from importlib.machinery import SourceFileLoader [as 别名]
# 或者: from importlib.machinery.SourceFileLoader import load_module [as 别名]
 def list_filaments(cls):
     filaments = {}
     for filament in os.listdir(FILAMENTS_DIR):
         path = os.path.join(FILAMENTS_DIR, filament)
         if path.endswith('.py'):
             name = os.path.basename(filament)[:-3]
             loader = SourceFileLoader(name, path)
             film = loader.load_module()
             filaments[name] = inspect.getdoc(film)
     return filaments

# 需要导入模块: from importlib.machinery import SourceFileLoader [as 别名]
# 或者: from importlib.machinery.SourceFileLoader import load_module [as 别名]
 def __init__(self, module_path, module_name):
     tyk.log( "Loading module: '{0}'".format(module_name), "info")
     self.module_path = module_path
     self.handlers = {}
     try:
         source = SourceFileLoader(module_name, self.module_path)
         self.module = source.load_module()
         self.register_handlers()
     except:
         tyk.log_error( "Middleware initialization error:" )

# 需要导入模块: from importlib.machinery import SourceFileLoader [as 别名]
# 或者: from importlib.machinery.SourceFileLoader import load_module [as 别名]
    def test_02(self):
        """
        Test Case 02:
        Try importing the magrathea script (Python>=3.4)

        Test is passed if a RuntimeError exception is raised.
        """
        path = os.path.abspath(os.path.join(os.path.dirname(__file__), '..', '..', 'scripts', 'magrathea.py'))
        with self.assertRaises(RuntimeError):
            loader = SourceFileLoader('magrathea', path)
            __ = loader.load_module()