如何检查一个对象是否是用`with`语句创建的？

Question

我想确保该类仅在“with”语句中实例化。

即这个没问题：

with X() as x:
 ...

这不是：

x = X()

我怎样才能确保这样的功能？

Answer 1

据我所知，没有直接的方法。但是，您可以有一个布尔标志，以在调用对象中的实际方法之前检查是否调用了 __enter__。

class MyContextManager(object):

    def __init__(self):
        self.__is_context_manager = False

    def __enter__(self):
        print "Entered"
        self.__is_context_manager = True
        return self

    def __exit__(self, exc_type, exc_value, traceback):
        print "Exited"

    def do_something(self):
        if not self.__is_context_manager:
            raise Exception("MyContextManager should be used only with `with`")

        print "I don't know what I am doing"

当您将它与with 一起使用时，

with MyContextManager() as y:
    y.do_something()

你会得到

Entered
I don't know what I am doing
Exited

但是，当你手动创建一个对象，并调用do_something，

x = MyContextManager()
x.do_something()

你会得到

Traceback (most recent call last):
  File "/home/thefourtheye/Desktop/Test.py", line 22, in <module>
    x.do_something()
  File "/home/thefourtheye/Desktop/Test.py", line 16, in do_something
    raise Exception("MyContextManager should be used only with `with`")
Exception: MyContextManager should be used only with `with`

注意：这不是一个固定的解决方案。有人可以在调用任何其他方法之前单独直接调用__enter__ 方法，并且在这种情况下可能永远不会调用__exit__ 方法。

如果你不想在每个函数中重复检查，你可以把它变成一个装饰器，像这样

class MyContextManager(object):

    def __init__(self):
        self.__is_context_manager = False

    def __enter__(self):
        print "Entered"
        self.__is_context_manager = True
        return self

    def __exit__(self, exc_type, exc_value, traceback):
        print "Exited"

    def ensure_context_manager(func):
        def inner_function(self, *args, **kwargs):
            if not self.__is_context_manager:
                raise Exception("This object should be used only with `with`")

            return func(self, *args, **kwargs)
        return inner_function

    @ensure_context_manager
    def do_something(self):
        print "I don't know what I am doing"

Answer 2

没有万无一失的方法来确保实例是在with 子句中构造的，但是您可以在__enter__ 方法中创建一个实例并返回它而不是self；这是将分配给x 的值。因此，您可以将X 视为在其__enter__ 方法中创建实际实例的工厂，类似于：

class ActualInstanceClass(object):
    def __init__(self, x):
        self.x = x

    def destroy(self):
        print("destroyed")

class X(object):
    instance = None
    def __enter__(self):

        # additionally one can here ensure that the
        # __enter__ is not re-entered,
        # if self.instance is not None:
        #     raise Exception("Cannot reenter context manager")
        self.instance = ActualInstanceClass(self)

    def __exit__(self, exc_type, exc_value, traceback):
        self.instance.destroy()
        return None

with X() as x:
    # x is now an instance of the ActualInstanceClass

当然这仍然是可重用的，但每个with 语句都会创建一个新实例。

当然可以手动调用__enter__，或者获取对ActualInstanceClass的引用，但这更多的是滥用而不是使用。

---

对于更难闻的方法，X() 在调用时确实会创建一个XFactory 实例，而不是X 实例；而这反过来又在用作上下文管理器时创建ActualX 实例，它是X 的子类，因此isinstance(x, X) 将返回true。

class XFactory(object):
    managed = None
    def __enter__(self):
        if self.managed:
            raise Exception("Factory reuse not allowed")

        self.managed = ActualX()
        return self.managed

    def __exit__(self, *exc_info):
        self.managed.destroy()
        return


class X(object):
    def __new__(cls):
        if cls == X:
            return XFactory()
        return super(X, cls).__new__(cls)

    def do_foo(self):
        print("foo")

    def destroy(self):
        print("destroyed")

class ActualX(X):
    pass

with X() as x:
    print(isinstance(x, X))  # yes it is an X instance
    x.do_foo()               # it can do foo

# x is destroyed

newx = X()
newx.do_foo()  # but this can't,
# AttributeError: 'XFactory' object has no attribute 'do_foo'

您可以更进一步，让XFactory 创建一个实际的X 实例，并为__new__ 提供一个特殊的关键字参数，但我认为这太黑魔法了。

Answer 3

到目前为止，所有答案都没有提供（我认为）OP直接想要的东西。
（我认为）OP 想要这样的东西：

>>> with X() as x:
 ...  # ok

>>> x = X()  # ERROR

Traceback (most recent call last):
  File "run.py", line 18, in <module>
    x = X()
  File "run.py", line 9, in __init__
    raise Exception("Should only be used with `with`")
Exception: Should only be used with `with`

这是我想出来的，它可能不是很健壮，但我认为它最接近 OP 的意图。

import inspect
import linecache

class X():
    
    def __init__(self):
        if not linecache.getline(__file__,
            inspect.getlineno(inspect.currentframe().f_back)).lstrip(
        ).startswith("with "):
            raise Exception("Should only be used with `with`")

    def __enter__(self):
        return self
    
    def __exit__(self, *exc_info):
        pass

只要在使用上下文管理器时with 与X() 在同一行，这将给出与我上面显示的完全相同的输出。

Answer 4

不幸的是，你不能很干净。

上下文管理器需要__enter__ 和__exit__ 方法，因此您可以使用它在类上分配一个成员变量以签入您的代码。

class Door(object):

    def __init__(self, state='closed'):
        self.state = state
        self.called_with_open = False

    # When being called as a non-context manger object,
    # __enter__ and __exit__ are not called.
    def __enter__(self):
        self.called_with_open = True
        self.state = 'opened'

    def __exit__(self, type, value, traceback):
        self.state = 'closed'

    def was_context(self):
        return self.called_with_open


if __name__ == '__main__':

    d = Door()
    if d.was_context():
        print("We were born as a contextlib object.")

    with Door() as d:
        print('Knock knock.')

有状态对象方法还有一个额外的好处，即能够判断__exit__ 方法是否在以后被调用，或者在以后的调用中干净地处理方法要求：

def walk_through(self):
    if self.state == 'closed':
        self.__enter__
    walk()

Answer 5

这是一个装饰器，可以自动确保方法不会在上下文管理器之外被调用：

from functools import wraps

BLACKLIST = dir(object) + ['__enter__']

def context_manager_only(cls):
    original_init = cls.__init__
    def init(self, *args, **kwargs):
        original_init(self, *args, **kwargs)
        self._entered = False
    cls.__init__ = init
    original_enter = cls.__enter__
    def enter(self):
        self._entered = True
        return original_enter(self)
    cls.__enter__ = enter

    attrs = {name: getattr(cls, name) for name in dir(cls) if name not in BLACKLIST}
    methods = {name: method for name, method in attrs.items() if callable(method)}

    for name, method in methods.items():
        def make_wrapper(method=method):
            @wraps(method)
            def wrapper_method(self, *args, **kwargs):
                if not self._entered:
                    raise Exception("Didn't get call to __enter__")
                return method(self, *args, **kwargs)
            return wrapper_method
        setattr(cls, name, make_wrapper())

    return cls

下面是它的使用示例：

@context_manager_only
class Foo(object):
    def func1(self):
        print "func1"

    def func2(self):
        print "func2"

    def __enter__(self):
        print "enter"
        return self

    def __exit__(self, *args):
        print "exit"

try:
    print "trying func1:"
    Foo().func1()
except Exception as e:
    print e

print "trying enter:"
with Foo() as foo:
    print "trying func1:"
    foo.func1()
    print "trying func2:"
    foo.func2()
    print "trying exit:"

这是对this duplicate question 的回复。

Answer 6

OP 的问题was believed to be an XY problem 和current chosen answer 确实（也是？）hacky。

我真的不知道 OP 最初的“X 问题”，但我认为动机并不是真的要“阻止 x = X() ASSIGNMENT 工作”。相反，它可能会强制 API 用户始终使用x 作为上下文管理器，以便始终触发其__exit__(...)，这就是将class X 设计为上下文管理器的重点。第一名。至少，这就是让我来这篇问答帖的原因。

class Holder(object):
    def __init__(self, **kwargs):
        self._data = allocate(...)  # Say, it allocates 1 GB of memory, or a long-lived connection, etc.
    def do_something(self):
        do_something_with(self._data)
    def tear_down(self):
        unallocate(self._data)

    def __enter__(self):
        return self
    def __exit__(self, *args):
        self.tear_down()

# This is desirable
with Holder(...) as holder:
    holder.do_something()

# This might not free the resource immediately, if at all
def foo():
    holder = Holder(...)
    holder.do_something()

也就是说，在学习了这里的所有对话之后，我最终还是让我的Holder 课程保持原样，好吧，我只是为我的tear_down() 添加了一个文档字符串：

    def tear_down(self):
        """You are expect to call this eventually; or you can simply use this class as a context manager."""
        ...

毕竟，我们这里都是成年人……