Python：元类+包装方法 +继承=问题

Question

我在Python中有一个问题，我找不到任何干净的解决方案......

调用某些方法时，我想在方法执行之前和之后执行一些代码。为了（以及其他许多事情）自动设置和清理 context 变量。

为了实现这一点，我声明了以下元类：

class MyType(type):
    def __new__(cls, name, bases, attrs):
        #wraps the 'test' method to automate context management and other stuff
        attrs['test'] = cls.other_wrapper(attrs['test'])
        attrs['test'] = cls.context_wrapper(attrs['test'])
        return super(MyType, cls).__new__(cls, name, bases, attrs)

    @classmethod
    def context_wrapper(cls, operation):
        def _manage_context(self, *args, **kwargs):
            #Sets the context to 'blabla' before the execution
            self.context = 'blabla'
            returned = operation(self, *args, **kwargs)
            #Cleans the context after execution
            self.context = None
            return returned
        return _manage_context

    @classmethod
    def other_wrapper(cls, operation):
        def _wrapped(self, *args, **kwargs):
            #DO something with self and *args and **kwargs
            return operation(self, *args, **kwargs)
        return _wrapped

这就像一个魅力：

class Parent(object):

    __metaclass__ = MyType

    def test(self):
        #Here the context is set:
        print self.context #prints blabla

但是当我想要子类化 Parent 时，当我使用 super 调用父方法时，就会出现问题 ：

class Child(Parent):
    def test(self):
        #Here the context is set too
        print self.context #prints blabla
        super(Child, self).test()
        #But now the context is unset, because Parent.test is also wrapped by _manage_context
        #so this prints 'None', which is not what was expected
        print self.context

我曾想过在将上下文设置为新值之前保存上下文，但这只能解决部分问题...

确实，（等等，这很难解释），调用了父方法，包装器被执行，但它们接收寻址到 Parent.test 的 *args 和 **kwargs，而 self 是一个 Child 实例，因此如果我想使用 *args 和 **kwargs 挑战它们，self 属性具有不相关的值> （例如用于自动验证目的），示例：

@classmethod
def validation_wrapper(cls, operation):
    def _wrapped(self, *args, **kwargs):
        #Validate the value of a kwarg
        #But if this is executed because we called super(Child, self).test(...
        #`self.some_minimum` will be `Child.some_minimum`, which is irrelevant
        #considering that we called `Parent.test`
        if not kwarg['some_arg'] > self.some_minimum:
            raise ValueError('Validation failed')
        return operation(self, *args, **kwargs)
    return _wrapped

所以基本上，为了解决这个问题，我看到了两种解决方案：

1. 防止在使用 super(Child, self) 调用方法时执行包装器

2. 拥有始终为 " 的 self right”类型

两种解决方案对我来说似乎都是不可能的......有人知道如何解决这个问题吗？一个建议？

Answer 1

那么，您不能只检查 _manage_context 中是否已设置上下文吗？像这样：

def _manage_context(self, *args, **kwargs):
    #Sets the context to 'blabla' before the execution
    if self.context is None:
        self.context = 'blabla'
        returned = operation(self, *args, **kwargs)
        #Cleans the context after execution
        self.context = None
        return returned
    else:
        return operation(self, *args, **kwargs)

此外，这可能应该包装在 try-catch 块中，以确保在发生异常时重置上下文。

Answer 2

实际上，我已经找到了一种方法来防止在使用 super(Child, self) 调用方法时执行包装器：

class MyType(type):
    def __new__(cls, name, bases, attrs):
        #wraps the 'test' method to automate context management and other stuff
        new_class = super(MyType, cls).__new__(cls, name, bases, attrs)
        new_class.test = cls.other_wrapper(new_class.test, new_class)

    @classmethod
    def other_wrapper(cls, operation, new_class):
        def _wrapped(self, *args, **kwargs):
            #DO something with self and *args and **kwargs ...
            #ONLY if self is of type *new_class* !!!
            if type(self) == new_class:
                pass #do things
            return operation(self, *args, **kwargs)
        return _wrapped

这样，在调用时：

super(Child, self).a_wrapped_method

包装代码被绕过！这很黑客，但它有效......

Answer 3

好吧，首先，你的“解决方案”真的很难看，但我想你知道这一点。 :-) 那么让我们尝试回答您的问题。

首先是一个隐含的“问题”：为什么不使用 Python 的上下文管理器？它们几乎免费为您提供更好的语法和错误管理。请参阅 contextlib 模块，它可以为您提供很大帮助。特别是请参阅有关重入的部分。

然后你会发现人们在尝试堆叠上下文管理器时通常会遇到问题。这并不奇怪，因为要正确支持递归，您需要一堆值，而不是单个值。 [您可以查看某些可重入 cm 的源代码，例如redirect_stdout，以了解它是如何处理的。]因此您的 context_wrapper 应该：

• （更干净）保留 self.context 的列表，进入上下文时附加到它，并在退出时从它弹出。这样你就总能获得你的上下文。

• （更像你想要的）保留一个self.context，同时也是一个全局值DEPTH，进入时加一，退出时减一，当 DEPTH 为 0 时，self.context 被重置为 None。

。至于你的第二个问题，我必须说我不太明白你的意思。 self 是的正确类型。如果 A 是 B 的子类，并且 self 是 A 的实例，那么它也是 B 的实例。如果 self.some_minimum 是“错误的”，无论您认为 self 是 A 的实例还是 B 的实例，这意味着 some_minimum 并不是真正的实例self 的实例属性，而是 A 或 B 的类属性。对吗？ 它们在 A 和 B 上可以自由不同，因为 A 和 B 是不同的对象（属于它们的元类）。