如何将方法从文件加载到现有类中（a plugin＆＃x27;方法）

Question

如果您愿意的话，请给我打电话奇怪，但很多人都有，但是我有一个很大的课程，我想通过从插件目录中加载的方法进行扩展。本质上，我正在猴子修补班。我几乎有效的方法，但是加载的方法并没有“看到” __ Main __中定义的全球。理想情况下，我希望一种告诉Globals（）（或实际使用的任何机制来定位全局变量）使用__ main __中存在的方法。这是我拥有的代码（为了简洁起见）：

#!/usr/bin/env python3

import importlib
import os
import types

main_global = "Hi, I'm in main"

class MyClass:

    def __init__(self, plugin_dir=None):

        if plugin_dir:
            self.load_plugins(plugin_dir, ext="plugin")

    def load_plugins(self, plugin_dir, ext):
        """ Load plugins

            Plugins are files in 'plugin_dir' that have the given extension.
            The functions defined within are imported as methods of this class.
        """
        cls = self.__class__

        # First check that we're not importing the same extension twice into
        # the same class.
        try:
            plugins = getattr(cls, "_plugins")
        except AttributeError:
            plugins = set()
            setattr(cls, "_plugins", plugins)

        if ext in plugins:
            return
        plugins.add(ext)

        for file in os.listdir(plugin_dir):
            if not file.endswith(ext):
                continue
            filename = os.path.join(plugin_dir, file)

            loader = importlib.machinery.SourceFileLoader("bar", filename)
            module = types.ModuleType(loader.name)
            loader.exec_module(module)

            for name in dir(module):
                if name.startswith("__"):
                    continue

                obj = getattr(module, name)
                if callable(obj):
                    obj = obj.__get__(self, cls)
                setattr(cls, name, obj)

z = MyClass(plugin_dir="plugins")
z.foo("Hello")

这是插件目录中的'foo.plugin'：

#!/usr/bin/env python3

foo_global = "I am global within foo"

def foo(self, value):
  print(f"I am foo, called with {self} and {value}")
  print(f"foo_global = {foo_global}")
  print(f"main_global = {main_global}")

输出是...

I am foo, called with <__main__.MyClass object at 0x7fd4680bfac8> and Hello
foo_global = I am global within foo
Traceback (most recent call last):
  File "./plugged", line 55, in <module>
    z.foo("Hello")
  File "plugins/foo.plugin", line 8, in foo
    print(f"main_global = {main_global}")
NameError: name 'main_global' is not defined

我知道这一切都感觉有点“ hacky”，但这是一个挑战因此，请不要在风格等上发火。

想法，学会的朋友？

Answer 1

您可以通过出厂功能和继承来解决问题。假设您的每个插件都是这样的，则在一个单独的导入文件中定义：

class MyPlugin:
    foo = 'bar'

    def extra_method(self):
        print(self.foo)

您可以使用这样的工厂：

def MyClassFactory(plugin_dir):

    def search_and_import_plugins(plugin_dir):
        # Look for all possible plugins and import them
        return plugin_list  # a list of plugin classes, like [MyPlugin]

    plugin_list = search_and_import_plugins(plugin_dir):

    class MyClass(*plugin_list):
         pass

    return MyClass()

z = MyClassFactory('/home/me/plugins')

Answer 2

您可以通过@martijn pieters'如何将变量注入装饰范围？将多个值注入类方法。

from functools import wraps
import importlib
import os
from pathlib import Path
import types


main_global = "Hi, I'm in main"

class MyClass:
    def __init__(self, plugin_dir=None):
        if plugin_dir:
            self.load_plugins(plugin_dir, ext="plugin")

    def load_plugins(self, plugin_dir, ext):
        """ Load plugins

            Plugins are files in 'plugin_dir' that have the given extension.
            The functions defined within are imported as methods of this class.
        """
        cls = self.__class__

        # First check that we're not importing the same extension twice into
        # the same class.
        try:
            plugins = getattr(cls, "_plugins")
        except AttributeError:
            plugins = set()
            setattr(cls, "_plugins", plugins)

        if ext in plugins:
            return
        plugins.add(ext)

        for file in Path(plugin_dir).glob(f'*.{ext}'):
            loader = importlib.machinery.SourceFileLoader("bar", str(file))
            module = types.ModuleType(loader.name)
            loader.exec_module(module)
            namespace = globals()

            for name in dir(module):
                if name.startswith("__"):
                    continue

                obj = getattr(module, name)
                if callable(obj):
                    obj = inject(obj.__get__(self, cls), namespace)

                setattr(cls, name, obj)


def inject(method, namespace):

    @wraps(method)
    def wrapped(*args, **kwargs):
        method_globals = method.__globals__

        # Save copies of any of method's global values replaced by the namespace.
        replaced = {key: method_globals[key] for key in namespace if key in method_globals}
        method_globals.update(namespace)

        try:
            method(*args[1:], **kwargs)
        finally:
            method_globals.update(replaced)  # Restore any replaced globals.

    return wrapped


z = MyClass(plugin_dir="plugins")
z.foo("Hello")

示例输出：

I am foo, called with <__main__.MyClass object at 0x0056F670> and Hello
foo_global = I am global within foo
main_global = Hi, I'm in main