Question

我正在使用Python 3来模拟其他工具提供的Python脚本界面。（编写此工具的脚本时，您运行Python脚本，可以import mytool访问脚本API。）

我已经实现了这个工具公开的接口，并且想编写一个你调用的加载器，如：

python run_mytool_script.py dump_menu_items.py

这个加载器允许您在不实际安装工具的情况下与工具的某些功能进行交互。理想情况下，这应该允许我在不修改的情况下运行为该工具设计的现有脚本。

在run_mytool_script.py内，我希望：

初始化模拟脚本界面
准备导入挂钩
exec脚本dump_menu_items.py

但是，我无法弄清楚如何创建导入钩子。如何安装一个钩子，以便在脚本执行mytool后，我的模拟脚本界面会以import mytool公开？

请注意，必须在运行时初始化模拟脚本接口，因此安装名为mytool的程序包不起作用。

Answer 1

嗯，有几种方法可以做到这一点。让我们从最复杂的一个开始 - mytool的完全动态创作。您可以使用imp模块创建一个新模块，然后定义其结构，最后将其添加到全局模块列表中，以便在同一个解释器堆栈中运行的所有模块都可以导入它：

run_mytool_script.py：

import imp
import sys

# lets first deal with loading of our external script so we don't waste cycles if a script
# was not provided as an argument
pending_script = None  # hold a script path we should execute
if __name__ == "__main__":  # make sure we're running this script directly, not imported
    if len(sys.argv) > 1:  # we need at least one argument to tell us which script to run
        pending_script = sys.argv[1]  # set the script to run as the first argument
    else:
        print("Please provide a path for a script to run")  # a script was not provided
        exit(1)

# now lets create the `mytool` module dynamically
mytool = imp.new_module("mytool")  # create a new module

def hello(name):  # define a local function
    print("Hello {}!".format(name))
mytool.__dict__["hello"] = hello  # add the function to the `mytool` module

sys.modules["mytool"] = mytool  # add 'mytool' to the global list so it can be imported

# now everything running in the same Python interpreter stack is able to import mytool
# lets run our `pending_script` if we're running the main script
if pending_script:
    try:
        execfile(pending_script)  # run the script
    except NameError:  # Python 3.x doesn't have execfile, use the exec function instead
        with open(pending_script, "r") as f:
            exec(f.read())  # read and run the script

现在，您可以创建另一个脚本，信任您在通过代理脚本运行时存在mytool模块，例如：

dump_menu_items.py：

import mytool
mytool.hello("Dump Menu Items")

现在当你运行它时：

$ python run_mytool_script.py dump_menu_items.py
Hello Dump Menu Items!

虽然整洁，但这是一项相当繁琐的工作 - 我建议您在mytool所在的同一文件夹中创建一个正确的run_mytool_script.py模块，让run_mytool_script.py初始化所有内容这需要，然后只需使用脚本的最后一部分来运行您的外部脚本 - 这更容易管理，通常是更好的方法。

Answer 2

按照cPython测试here中的示例，我提出了以下可能的解决方案。当我意识到它的优点和缺点时，我会更新这篇文章。

class HookedImporter(importlib.abc.MetaPathFinder, importlib.abc.Loader):
    def __init__(self, hooks=None):
        self.hooks = hooks

    def find_spec(self, name, path, target=None):
        if name not in self.hooks:
            return None

        spec = importlib.util.spec_from_loader(name, self)
        return spec

    def create_module(self, spec):
        # req'd in 3.6
        logger.info('hooking import: %s', spec.name)
        module = importlib.util._Module(spec.name)
        mod = self.hooks[spec.name]
        for attr in dir(mod):
            if attr.startswith('__'):
                continue
            module.__dict__[attr] = getattr(mod, attr)
        return module

    def exec_module(self, module):
        # module is already loaded (imported by line `import idb` above),
        # so no need to re-execute.
        #
        # req'd in 3.6.
        return

    def install(self):
        sys.meta_path.insert(0, self)

......以后的某个地方...

api = mytool.from_config(...)
hooks = {
    'mytool': api.mytool,
}

importer = HookedImporter(hooks=hooks)
importer.install()


with open(args.script_path, 'rb') as f:
    g = {
        '__name__': '__main__',
    }
    g.update(hooks)
    exec(f.read(), g)

如何在Python 3中执行文件并提供钩子导入？

2 个答案: