python - 将参数传递给解上下文装饰器

Question

我有一个辅助类Decontext，我用它来将上下文管理器变成装饰器(pyton 2.6)。

class Decontext(object):
    """
    makes a context manager also act as decorator
    """

    def __init__(self, context_manager):
        self._cm = context_manager

    def __enter__(self):
        return self._cm.__enter__()

    def __exit__(self, *args, **kwds):
        return self._cm.__exit__(*args, **kwds)

    def __call__(self, func):
        def wrapper(*args, **kwds):
            with self:
                return func(*args, **kwds)

        return wrapper

我的 contextmanager 接受一个参数，我试图弄清楚如何在使用此装饰器时传递该参数？

@contextmanager
def sample_t(arg1):
print "<%s>" % arg1
        yield

这就是我使用它的方式，但失败了:

my_deco =  Decontext(sample_t)

@my_deco(arg1='example')
def some_func()
     print 'works'

编辑:

我希望在 __call__ 函数执行时，Decontext 类传递 context_manager 中的所有 *args。

示例:

decorator_example = Decontext(sample_t) // I don't want to pass in the argument here but when the decorator is created. How can I modify my class to make this enhancement

编辑2:

我所期望的示例

my_deco =  Decontext(sample_t)

@my_deco(arg1='example')
def some_func()
     print 'works'

预期输出:

'example' // running and passing argument to context_manager
'works' // after yield executing some_func 

Answer 1

您遇到的问题是，您在 __init__ 方法中设置的 _cm 属性实际上并不存储上下文管理器实例，而是存储上下文管理器的类型(或者可能是生成上下文管理器实例的工厂函数)。您需要稍后调用类型或工厂来获取实例。

试试这个，它应该适用于上下文管理器实例(假设它们也不可调用)和需要参数的上下文管理器类型:

class Decontext(object):
    """
    makes a context manager also act as decorator
    """

    def __init__(self, context_manager):
        self._cm = context_manager   # this may be a cm factory or type, but that's OK

    def __enter__(self):
        return self._cm.__enter__()

    def __exit__(self, *args, **kwds):
        return self._cm.__exit__(*args, **kwds)

    def __call__(self, *cm_args, **cm_kwargs):
        try:
            self._cm = self._cm(*cm_args, **cm_kwargs) # try calling the cm like a type
        except TypeError:
            pass
        def decorator(func):
            def wrapper(*args, **kwds):
                with self:
                    return func(*args, **kwds)

            return wrapper
        return decorator

其中存在相当愚蠢的嵌套级别，但鉴于您想要调用该事物的方式，这就是您所需要的。这是一个实际的示例:

from contextlib import contextmanager

@contextmanager
def foo(arg):
    print("entered foo({!r})".format(arg))
    yield
    print("exited foo({!r})".format(arg))

foo_deco_factory = Decontext(foo)

@foo_deco_factory("bar")
def baz(arg):
    print("called baz({!r})".format(arg))

baz("quux")

它将输出:

entered foo("bar")
called baz("quux")
exited foo("bar")

请注意，尝试使用 foo_deco_factory 作为上下文管理器将不起作用(类似于使用 with foo 不起作用)。仅当使用上下文管理器实例(而不是类型或工厂)初始化或已使用适当的参数将其作为装饰器调用时，在 Decontext 实例上使用上下文管理器协议(protocol)才有效。

如果您不需要装饰器本身能够充当上下文管理器，您可以很容易地将整个类变成一个函数(使用 __call__ 成为一个额外的闭包级别，而不是方法):

def decontext(cm_factory):
    def factory(*cm_args, **cm_kwargs):
        cm = cm_factory(*cm_args, **cm_kwargs)
        def decorator(func):
            def wrapper(*args, **kwargs):
                with cm:
                    return func(*args, **kwargs)
            return wrapper
        return decorator
    return factory

为了简化本例中的代码，我始终假设您传递的是上下文管理器工厂，而不是上下文管理器实例。