腌制和复制持久对象的类？

Question

我正在尝试为只读对象编写一个类，该对象不会使用 copy 模块真正复制，并且当它被腌制以在进程之间传输时，每个进程将维护不超过它的一个副本，无论它作为“新”对象传递多少次。已经有类似的事情了吗？

Answer 1

我尝试着实现这一点。 @Alex Martelli 和其他人，请给我评论/改进。我认为这最终会出现在 GitHub 上。

"""
todo: need to lock library to avoid thread trouble?

todo: need to raise an exception if we're getting pickled with
an old protocol?

todo: make it polite to other classes that use __new__. Therefore, should
probably work not only when there is only one item in the *args passed to new.

"""

import uuid
import weakref

library = weakref.WeakValueDictionary()

class UuidToken(object):
    def __init__(self, uuid):
        self.uuid = uuid


class PersistentReadOnlyObject(object):
    def __new__(cls, *args, **kwargs):
        if len(args)==1 and len(kwargs)==0 and isinstance(args[0], UuidToken):
            received_uuid = args[0].uuid
        else:
            received_uuid = None

        if received_uuid:
            # This section is for when we are called at unpickling time
            thing = library.pop(received_uuid, None)
            if thing:
                thing._PersistentReadOnlyObject__skip_setstate = True
                return thing
            else: # This object does not exist in our library yet; Let's add it
                new_args = args[1:]
                thing = super(PersistentReadOnlyObject, cls).__new__(cls,
                                                                     *new_args,
                                                                     **kwargs)
                thing._PersistentReadOnlyObject__uuid = received_uuid
                library[received_uuid] = thing
                return thing

        else:
            # This section is for when we are called at normal creation time
            thing = super(PersistentReadOnlyObject, cls).__new__(cls, *args,
                                                                 **kwargs)
            new_uuid = uuid.uuid4()
            thing._PersistentReadOnlyObject__uuid = new_uuid
            library[new_uuid] = thing
            return thing

    def __getstate__(self):
        my_dict = dict(self.__dict__)
        del my_dict["_PersistentReadOnlyObject__uuid"]
        return my_dict

    def __getnewargs__(self):
        return (UuidToken(self._PersistentReadOnlyObject__uuid),)

    def __setstate__(self, state):
        if self.__dict__.pop("_PersistentReadOnlyObject__skip_setstate", None):
            return
        else:
            self.__dict__.update(state)

    def __deepcopy__(self, memo):
        return self

    def __copy__(self):
        return self

# --------------------------------------------------------------
"""
From here on it's just testing stuff; will be moved to another file.
"""


def play_around(queue, thing):
    import copy
    queue.put((thing, copy.deepcopy(thing),))

class Booboo(PersistentReadOnlyObject):
    def __init__(self):
        self.number = random.random()

if __name__ == "__main__":

    import multiprocessing
    import random
    import copy

    def same(a, b):
        return (a is b) and (a == b) and (id(a) == id(b)) and \
               (a.number == b.number)

    a = Booboo()
    b = copy.copy(a)
    c = copy.deepcopy(a)
    assert same(a, b) and same(b, c)

    my_queue = multiprocessing.Queue()
    process = multiprocessing.Process(target = play_around,
                                      args=(my_queue, a,))
    process.start()
    process.join()
    things = my_queue.get()
    for thing in things:
        assert same(thing, a) and same(thing, b) and same(thing, c)
    print("all cool!")

Answer 2

我不知道已经实现了任何此类功能。有趣的问题如下，需要精确的规范来说明在这种情况下会发生什么...：

• 进程 A 制作 obj 并将其发送到 B，B 对其进行 unpickle，到目前为止，
• A 已将 X 更改为 obj，同时B 对 obj 的 ITS 副本进行更改，
• 现在任一进程将其 obj 发送到另一个进程，这会取消它：发生了什么变化
  此时该对象需要在每个进程中可见？这有关系吗
  A 是否发送给 B，反之亦然，即 A 是否“拥有”该对象？或者什么？

如果你不在乎，比如说因为只有 A 拥有 obj——只有 A 才被允许进行更改并将 obj 发送给其他人，其他人不能也不会更改——那么问题就归结为识别 obj唯一的——一个 GUID 就可以了。该类可以维护一个将 GUID 映射到现有实例的类属性字典（可能作为弱值字典以避免使实例不必要地保持活动状态，但这是一个附带问题）并确保在适当的时候返回现有实例。

但是，如果需要将更改同步到任何更细的粒度，那么突然之间，这就是分布式计算的一个非常困难的问题，并且在什么情况下发生的情况的规范确实需要非常小心地确定（并且比大多数情况下更加偏执）对于我们来说——分布式编程是非常棘手的，除非狂热地遵循一些简单且可证明正确的模式和习惯用法！-）。

如果您能为我们确定规格，我可以提供一个草图，说明我将如何努力满足这些规格。但我不会代表您猜测规格；-)。

编辑：OP已经澄清了，看来他所需要的只是更好地理解如何控制__new__。这很简单：请参阅 __getnewargs__ - - 您需要一个新式类并使用协议 2 或更好的进行酸洗（但出于其他原因，这些都是明智的！-），然后现有对象中的 __getnewargs__ 可以简单地返回对象的 GUID（其中 __new__ 必须作为可选参数接收）。因此 __new__ 可以检查 GUID 是否存在于类的 memo [[weakvalue;-)]]dict 中（如果存在，则返回相应的对象值）——如果不存在（或者如果 GUID 未传递，则意味着它不是 unpickling，因此必须生成新的 GUID），然后创建一个真正的新对象（设置其 GUID;-）并将其记录在类级 中备忘录。

顺便说一句，要制作 GUID，请考虑使用标准库中的 uuid 模块。

Answer 3

您可以简单地使用一个字典，其键和值在接收器中相同。为了避免内存泄漏，请使用 Wea​​kKeyDictionary。