包装一个类，其方法返回该类的实例

Question

我需要编写一个类来包装来自第三方包的类。通常，第三方类具有返回第三方类实例的方法。这些方法的包装版本必须将这些实例转换为包装类的实例，但我无法使其工作。我正在使用带有新样式类的 Python 2.7。

基于Create a wrapper class to call a pre and post function around existing functions?，我有以下内容。

import copy

class Wrapper(object):
    __wraps__  = None

    def __init__(self, obj):
        if self.__wraps__ is None:
            raise TypeError("base class Wrapper may not be instantiated")
        elif isinstance(obj, self.__wraps__):
            self._obj = obj
        else:
            raise ValueError("wrapped object must be of %s" % self.__wraps__)

    def __getattr__(self, name):
        orig_attr = self._obj.__getattribute__(name)
        if callable(orig_attr):
            def hooked(*args, **kwargs):
                result = orig_attr(*args, **kwargs)
                if result == self._obj:
                    return result
                return self.__class__(result)
            return hooked
        else:
            return orig_attr

class ClassToWrap(object):
    def __init__(self, data):
        self.data = data

    def theirfun(self):
        new_obj = copy.deepcopy(self)
        new_obj.data += 1
        return new_obj

class Wrapped(Wrapper):
    __wraps__ = ClassToWrap

    def myfun(self):
        new_obj = copy.deepcopy(self)
        new_obj.data += 1
        return new_obj

obj = ClassToWrap(0)
wr0 = Wrapped(obj)
print wr0.data
>> 0
wr1 = wr0.theirfun()
print wr1.data
>> 1
wr2 = wr1.myfun()
print wr2.data
>> 2
wr3 = wr2.theirfun()
print wr3.data
>> 2

现在为什么theirfun() 第一次工作，第二次却不行？ wr0 和 wr2 都是 Wrapped 类型，调用 wr2.theirfun() 不会引发错误，但不会像预期的那样将 1 添加到 wr2.data。

抱歉，我不在寻找以下替代方法：

1. 猴子补丁。我的代码库很重要，我不知道如何确保补丁能够通过导入语句的网络传播。
2. 为每个第三方包的所有这些棘手的方法编写单独的包装方法。它们太多了。

ETA：有几个有用的答案引用了 _obj 类之外的基础 _obj 属性。然而，这种方法的重点是可扩展性，所以这个功能需要在Wrapper 类中。 myfun 需要按预期运行，而不在其定义中引用 _obj。

Answer 1

问题在于您在Wrapped 类中实现myfun。您只更新了类实例的data 成员，但包装类（ClassToWrap 实例，即_obj）data 成员已过时，使用来自theirfun 的上一个调用的值。

您需要在两个实例之间同步数据值：

class Wrapper(object):
    ...
    def __setattr__(self, attr, val):
        object.__setattr__(self, attr, val)
        if getattr(self._obj, attr, self._obj) is not self._obj: # update _obj's member if it exists
            setattr(self._obj, attr, getattr(self, attr))


class Wrapped(Wrapper):
    ...
    def myfun(self):
        new_obj = copy.deepcopy(self)
        new_obj.data += 1
        return new_obj

obj = ClassToWrap(0)
wr0 = Wrapped(obj)
print wr0.data
# 0
wr1 = wr0.theirfun()
print wr1.data
# 1
wr2 = wr1.myfun()
print wr2.data
# 2
wr3 = wr2.theirfun()
print wr3.data
# 3
wr4 = wr3.myfun()
print wr4.data
# 4
wr5 = wr4.theirfun()
print wr5.data
# 5

Answer 2

问题在于myfun 中的分配new_obj.data += 1。问题在于new_obj 是Wrapped 的实例，而不是ClassToWrap 的实例。您的 Wrapper 基类仅支持在代理对象上查找属性。它不支持对属性的分配。增强分配两者兼而有之，因此不能完全正确地工作。

您可以通过稍微改变一下 myfun 使其正常工作：

def myfun(self):
    new_obj = copy.deepcopy(self._obj)
    new_obj.data += 1
    return self.__class__(new_obj) # alternative spelling: return type(self)(new_obj)

解决此问题的另一种方法是将__setattr__ 方法添加到Wrapper，但让它正常工作（不干扰代理类自身的属性）会有点尴尬。

与您当前的问题无关，您还可能会泄漏 hooked 包装函数中的包装对象。如果您调用的方法返回了调用它的对象（例如，该方法执行了return self），则您当前返回的是未包装的对象。您可能希望将 return result 更改为 return self 以便返回当前包装器。您可能还需要检查返回值以查看它是否是您能够包装的类型。目前，如果方法返回字符串或数字或包装类型实例以外的任何内容，您的代码将失败。

        def hooked(*args, **kwargs):
            result = orig_attr(*args, **kwargs)
            if result == self._obj:
                return self                            # fix for leaking objects
            elif isisntance(result, self.__wraps__): # new type check
                return self.__class__(result)
            else:
                return result              # fallback for non-wrappable return values