使用importlib加载外部插件：无需__init__.py实现相对导入

问题背景 #

我通过以下代码从非sys.path路径加载Python插件：

import importlib.util
import sys

def load_module(module_name, file_path):
    spec = importlib.util.spec_from_file_location(module_name, file_path)
    module = importlib.util.module_from_spec(spec)
    sys.modules[module_name] = module
    spec.loader.exec_module(module)
    return module

plugin_module = load_module("some_plugin", "/path/to/plugins/some_plugin.py")

希望支持插件使用相对导入（例如from . import plugin_common），但执行时会抛出错误：

ImportError: attempted relative import with no known parent package

原因是加载的模块不属于任何包，__package__属性为空，无法解析相对导入路径。

现有解决方案要求用户在插件目录添加__init__.py文件，先加载父包再加载插件：

load_module("plugins_package", "/path/to/plugins/__init__.py")
plugin_module = load_module("plugins_package.some_plugin", "/path/to/plugins/some_plugin.py")

但我希望避免强制用户创建__init__.py，基于PEP 0420定义的命名空间包特性，提出以下三个问题：

1. 能否动态创建命名空间包并将plugin_module放入其中？
2. 能否动态创建无需__init__.py的普通包？
3. 是否有更好的方法实现从非sys.path路径动态加载的模块使用相对导入？

问题1：动态创建命名空间包并挂载插件模块 #

可以。命名空间包的核心标识是存在__path__属性，只需在sys.modules中注册符合包结构的模块对象，并正确设置插件模块的__package__属性即可。

示例代码：

import importlib.util
import sys
import types

def create_namespace_package(package_name, package_path):
    # 创建命名空间包模块并注册到sys.modules
    package = types.ModuleType(package_name)
    package.__path__ = [package_path]  # 命名空间包必须具备__path__属性
    sys.modules[package_name] = package
    return package

def load_module_in_namespace(package_name, module_name, file_path):
    full_module_name = f"{package_name}.{module_name}"
    # 确保父命名空间包已存在
    if package_name not in sys.modules:
        create_namespace_package(package_name, "/path/to/plugins")
    # 加载并初始化插件模块
    spec = importlib.util.spec_from_file_location(full_module_name, file_path)
    module = importlib.util.module_from_spec(spec)
    module.__package__ = package_name  # 显式指定父包
    sys.modules[full_module_name] = module
    spec.loader.exec_module(module)
    return module

# 使用示例
plugin_module = load_module_in_namespace("plugins_namespace", "some_plugin", "/path/to/plugins/some_plugin.py")

此方法下，插件中的相对导入可正常解析，无需用户创建__init__.py。

问题2：动态创建无需__init__.py的普通包 #

不行。Python中普通包（非命名空间包）的定义依赖于__init__.py文件，动态创建的模块即使设置了__path__属性，本质上仍属于命名空间包，无法成为传统意义上的普通包。Python会通过是否存在__init__.py来区分两者，没有绕过这一机制的方法。

问题3：更优的实现方案 #

除了上述命名空间包方案，还有两种更简洁的实现思路：

方案1：将插件目录加入sys.path后直接导入

将插件所在目录添加到sys.path，然后用importlib.import_module导入模块，此时模块会自动属于该目录对应的隐式命名空间包：

import sys
import importlib

sys.path.append("/path/to/plugins")
plugin_module = importlib.import_module("some_plugin")

这种方式下插件可直接使用相对导入，无需额外配置，但需注意：如果sys.path中已有同名模块，会引发导入冲突。

方案2：通过SourceFileLoader显式指定父包

使用importlib.machinery.SourceFileLoader加载模块时，自动创建并注册父命名空间包，同时设置插件模块的__package__属性：

import importlib.machinery
import sys
import types
import os

def load_plugin_with_relative_imports(module_name, file_path):
    # 解析父包名称，未指定则用插件目录名作为命名空间包名
    parent_package_name, _, mod_name = module_name.rpartition('.')
    if not parent_package_name:
        parent_package_name = os.path.basename(os.path.dirname(file_path))
        # 注册父命名空间包
        if parent_package_name not in sys.modules:
            package = types.ModuleType(parent_package_name)
            package.__path__ = [os.path.dirname(file_path)]
            sys.modules[parent_package_name] = package
        module_name = f"{parent_package_name}.{mod_name}"
    
    # 加载并初始化模块
    loader = importlib.machinery.SourceFileLoader(module_name, file_path)
    spec = importlib.util.spec_from_loader(module_name, loader, origin=file_path)
    module = importlib.util.module_from_spec(spec)
    module.__package__ = parent_package_name
    sys.modules[module_name] = module
    loader.exec_module(module)
    return module

# 使用示例
plugin_module = load_plugin_with_relative_imports("some_plugin", "/path/to/plugins/some_plugin.py")

该方案自动处理父包的创建，无需用户干预，同时避免了sys.path冲突问题，是较推荐的实现方式。

内容的提问来源于stack exchange，提问作者Martin