Question

我正在编写GUI库，我想让程序员提供有关其程序的元信息，我可以使用它来微调GUI。我打算为此目的使用函数装饰器，例如：

class App:
    @Useraction(description='close the program', hotkey='ctrl+q')
    def quit(self):
        sys.exit()

问题是这些信息需要绑定到相应的类。例如，如果程序是图像编辑器，它可能有一个Image类，它提供了更多的Useractions：

class Image:
    @Useraction(description='invert the colors')
    def invert_colors(self):
        ...

但是，由于在python 3中删除了未绑定方法的概念，因此似乎找不到函数定义类的方法。（我发现this old answer，但这在装饰器中不起作用。）

所以，既然装饰师看起来不会起作用，那么最好的方法是什么？我想避免使用像

这样的代码

class App:
    def quit(self):
        sys.exit()

Useraction(App.quit, description='close the program', hotkey='ctrl+q')

如果可能的话。

为了完整性＆＃39;为此，@Useraction装饰器看起来有点像这样：

class_metadata= defaultdict(dict)
def Useraction(**meta):
    def wrap(f):
        cls= get_defining_class(f)
        class_metadata[cls][f]= meta
        return f
    return wrap

Answer 1

您正在使用装饰器将元数据添加到方法中。那样就好。它可以完成，例如这样：

def user_action(description):
    def decorate(func):
        func.user_action = {'description': description}
        return func
    return decorate

现在，您希望收集该数据并将其存储在class_metadata[cls][f]= meta格式的全局字典中。为此，您需要找到所有装饰的方法及其类。

最简单的方法是使用元类。在元类中，您可以定义创建类时发生的情况。在这种情况下，遍历类的所有方法，找到修饰的方法并将它们存储在字典中：

class UserActionMeta(type):
    user_action_meta_data = collections.defaultdict(dict)

    def __new__(cls, name, bases, attrs):
        rtn = type.__new__(cls, name, bases, attrs)
        for attr in attrs.values():
            if hasattr(attr, 'user_action'):
                UserActionMeta.user_action_meta_data[rtn][attr] = attr.user_action
        return rtn

我把全局字典user_action_meta_data放在元类中只是因为它感觉合乎逻辑。它可以在任何地方。

现在，只需在任何类中使用它：

class X(metaclass=UserActionMeta):

    @user_action('Exit the application')
    def exit(self):
        pass

静态UserActionMeta.user_action_meta_data现在包含您想要的数据：

defaultdict(<class 'dict'>, {<class '__main__.X'>: {<function exit at 0x00000000029F36C8>: {'description': 'Exit the application'}}})

Answer 2

我找到了一种让装饰器与inspect模块配合使用的方法，但它并不是一个很好的解决方案，所以我仍然愿意接受更好的建议。

基本上我正在做的是遍历解释器堆栈，直到找到当前的类。由于此时不存在类对象，我改为提取类的名称和模块。

import inspect

def get_current_class():
    """
    Returns the name of the current module and the name of the class that is currently being created.
    Has to be called in class-level code, for example:

    def deco(f):
        print(get_current_class())
        return f

    def deco2(arg):
        def wrap(f):
            print(get_current_class())
            return f
        return wrap

    class Foo:
        print(get_current_class())

        @deco
        def f(self):
            pass

        @deco2('foobar')
        def f2(self):
            pass
    """
    frame= inspect.currentframe()
    while True:
        frame= frame.f_back
        if '__module__' in frame.f_locals:
            break
    dict_= frame.f_locals
    cls= (dict_['__module__'], dict_['__qualname__'])
    return cls

然后在一个后处理步骤中，我使用模块和类名来查找实际的类对象。

def postprocess():
    global class_metadata

    def findclass(module, qualname):
        scope= sys.modules[module]
        for name in qualname.split('.'):
            scope= getattr(scope, name)
        return scope

    class_metadata= {findclass(cls[0], cls[1]):meta for cls,meta in class_metadata.items()}

此解决方案的问题是延迟的类查找。如果类被覆盖或删除，则后处理步骤将找到错误的类或完全失败。例如：

class C:
    @Useraction(hotkey='ctrl+f')
    def f(self):
        print('f')

class C:
    pass

postprocess()

用于保存类

2 个答案: