如何在方法的所有装饰器的基础上应用类装饰器

Question

我正在用这种方式装饰所有方法

import inspect

def decallmethods(decorator, prefix='test_'):
  def dectheclass(cls):
    for name, m in inspect.getmembers(cls, inspect.ismethod):
      if name.startswith(prefix):
        setattr(cls, name, decorator(m))
    return cls
  return dectheclass


@decallmethods(login_testuser)
class TestCase(object):
    def setUp(self):
        pass

    def test_1(self):
        print "test_1()"

    def test_2(self):
        print "test_2()"

这是有效的，但它适用于顶部，如果我有其他装饰器。

我的意思是

现在的结果是

@login_testuser
@other
def test_2(self):
    print "test_2()"

但我想要

@other
@login_testuser
def test_2(self):
    print "test_2()"

Answer 1

这当然是一个坏主意，但你想做的事情可以在某种程度上完成，这需要花费大量时间来解释。 首先，不要将装饰器视为语法糖，而应将它们视为它们的真实含义：一个函数（即一个闭包），其中存在一个函数。 现在这已经不在了，假设我们有一个功能：

def operation(a, b):
    print('doing operation')
    return a + b

它只会这样做

>>> hi = operation('hello', 'world')
doing operation
>>> print(hi)
helloworld

现在定义一个装饰器，在调用它的内部函数之前和之后打印一些东西（相当于你以后要装饰的other装饰器）：

def other(f):  
    def other_inner(*a, **kw):
        print('other start')
        result = f(*a, **kw)
        print('other finish')
        return result
    return other_inner

有了它，建立一个新的功能和装饰

@other
def o_operation(a, b):
    print('doing operation')
    return a + b

记住，这基本上等同于o_operation = other(operation)

运行此命令以确保其有效：

>>> r2 = o_operation('some', 'inner')
other start
doing operation
other finish
>>> print(r2)
someinner

最后，您希望在operation之前立即调用最终装饰器而不是d_operation ，但是使用现有代码会导致以下结果：

def inject(f):
    def injected(*a, **kw):
        print('inject start')
        result = f(*a, **kw)
        print('inject finish')
        return result
    return injected

@inject
@other
def i_o_operation(a, b):
    print('doing operation')
    return a + b

运行以上：

>>> i_o_operation('hello', 'foo')
inject start
other start
doing operation
other finish
inject finish
'hellofoo'

正如前面提到的那样，装饰器真的是封闭的，因此这就是为什么内部的物品可以在里面有效实例化的原因。 您可以通过__closure__属性与他们__closure__ ：

>>> i_o_operation.__closure__
(<cell at 0x7fc0eabd1fd8: function object at 0x7fc0eabce7d0>,)
>>> i_o_operation.__closure__[0].cell_contents
<function other_inner at 0x7fc0eabce7d0>
>>> print(i_o_operation.__closure__[0].cell_contents('a', 'b'))
other start
doing operation
other finish
ab

看看它如何有效地直接调用injected闭包内的函数，就好像它被解包一样。 如果关闭可以用注射剂替换怎么办？ 对于我们所有的保护， __closure__和cell.cell_contents是只读的。 需要做的是通过使用FunctionType函数构造函数（在types模块中找到）构造具有预期闭包的全新函数

回到问题所在。 因为我们现在拥有的是：

i_o_operation = inject(other(operation))

而我们想要的是

o_i_operation = other(inject(operation))

我们实际上必须以某种方式从i_o_operation剥离对其other的调用，并以某种方式用inject包装它来生成o_i_operation 。 （休息后跟随龙）

---

首先，构造一个有效调用inject(operation)的函数，通过将闭包调深（使f只包含原始operation调用），但将其与inject(f)生成的代码混合：

i_operation = FunctionType(
    i_o_operation.__code__,
    globals=globals(),
    closure=i_o_operation.__closure__[0].cell_contents.__closure__,
) 

由于i_o_operation是inject(f)的结果，我们可以使用该代码生成一个新函数。 globals是必需的形式，最后采用嵌套级别的闭包，并生成函数的第一部分。 验证是否未调用other 。

>>> i_operation('test', 'strip')
inject start
doing operation
inject finish
'teststrip'

整齐。 但是我们仍然希望将other包裹在其中以最终生成o_i_operation 。 我们确实需要以某种方式将我们生成的这个新函数放在一个闭包中，一种方法是创建一个代理函数来生成一个

def closure(f):
    def surrogate(*a, **kw):
        return f(*a, **kw)
    return surrogate

并简单地用它来构造和提取我们的闭包

o_i_operation = FunctionType(
    i_o_operation.__closure__[0].cell_contents.__code__,
    globals=globals(),
    closure=closure(i_operation).__closure__,
)

叫这个：

>>> o_i_operation('job', 'complete')
other start
inject start
doing operation
inject finish
other finish
'jobcomplete'

看起来我们终于得到了我们需要的东西。 虽然这并没有完全回答你的确切问题，但这开始了正确的轨道，但已经非常毛茸茸。

---

现在针对实际问题：一个函数将确保装饰器函数在给定的原始未修饰函数之前是最内部（最终）可调用的 - 即对于给定target和f(g(...(callable)) ，我们想要模拟给出f(g(...(target(callable)))) 。这是代码：

from types import FunctionType

def strip_decorators(f):
    """
    Strip all decorators from f.  Assumes each are functions with a
    closure with a first cell being the target function.
    """

    # list of not the actual decorator, but the returned functions
    decorators = []
    while f.__closure__:
        # Assume first item is the target method
        decorators.append(f)
        f = f.__closure__[0].cell_contents
    return decorators, f

def inject_decorator(decorator, f):
    """
    Inject a decorator to the most inner function within the stack of
    closures in `f`.
    """

    def closure(f):
        def surrogate(*a, **kw):
            return f(*a, **kw)
        return surrogate

    decorators, target_f = strip_decorators(f)
    result = decorator(target_f)

    while decorators:
        # pop out the last one in
        decorator = decorators.pop()
        result = FunctionType(
            decorator.__code__,
            globals=globals(),
            closure=closure(result).__closure__,
        )

    return result

为了测试这个，我们使用典型的用例 - html标签示例。

def italics(f):
    def i(s):
        return '<i>' + f(s) + '</i>'
    return i

def bold(f):
    def b(s):
        return '<b>' + f(s) + '</b>'
    return b

def underline(f):
    def u(s):
        return '<u>' + f(s) + '</u>'
    return u

@italics
@bold
def hi(s):
    return s

运行测试。

>>> hi('hello')
'<i><b>hello</b></i>'

我们的目标是将underline装饰器（特别是u(hi)可调用的）注入到最内部的闭包中。 这可以这样做，使用我们上面定义的函数：

>>> hi_u = inject_decorator(underline, hi)
>>> hi_u('hello')
'<i><b><u>hello</u></b></i>'

使用未修饰的功能：

>>> def pp(s):
...     return s 
... 
>>> pp_b = inject_decorator(bold, pp)
>>> pp_b('hello')
'<b>hello</b>'

这个重写器的第一个版本的一个主要假设是，链中的所有装饰器只有一个闭包长度，一个元素是装饰的函数。 拿这个装饰器为例：

def prefix(p):
    def decorator(f):
        def inner(*args, **kwargs):
            new_args = [p + a for a in args]
            return f(*new_args, **kwargs)
        return inner
    return decorator

用法示例：

>>> @prefix('++')
... def prefix_hi(s):
...     return s
... 
>>> prefix_hi('test')
'++test'

现在尝试注入一个bold装饰器，如下所示：

>>> prefix_hi_bold = inject_decorator(bold, prefix_hi)
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
  File "<stdin>", line 18, in inject_decorator
ValueError: inner requires closure of length 2, not 1

这只是因为prefix的decorator形成的闭包有两个元素，一个是前缀字符串p ，第二个是实际函数，而inner嵌套在里面，期望它们都存在于其闭包内。 解决这个问题需要更多代码来分析和重建细节。

---

无论如何，这个解释需要相当多的时间和文字，所以我希望你能理解这一点，也许会让你开始实际的正确轨道。

如果你想将inject_decorator变成装饰器，和/或将它混合到你的类装饰器中，祝你好运，大部分艰苦的工作已经完成。