Класс для маринованных и сохраняющих копию объектов?

Question

Я пытаюсь написать класс для объекта, доступного только для чтения, который на самом деле не будет скопирован с модулем copy, и когда он будет выбран для передачи между процессами, каждый процесс будет поддерживать не более одной копии. о нем, независимо от того, сколько раз он будет передан как «новый» объект. Уже есть что-то подобное?

Answer 1

Я попытался реализовать это. @ Алекс Мартелли и все остальные, пожалуйста, дайте мне комментарии / улучшения. Я думаю, что это в конечном итоге окажется на 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 создает объект и отправляет его B, который его расправляет, пока все хорошо
• A вносит изменения X в объект, в то время как B меняет Y на его копию объекта
• теперь любой процесс отправляет свой объект другому, который его распаковывает: что меняется объект должен быть виден в это время в каждом процессе ? это имеет значение отправляет ли A на B или наоборот, т. е. «владеет» ли объект? или что?

Если вам все равно, скажем, потому что только СОБСТВЕННО для объекта - только А когда-либо разрешено вносить изменения и отправлять объект другим, другие не могут и не будут меняться - тогда проблемы сводятся к чтобы идентифицировать obj однозначно - подойдет GUID. Класс может поддерживать атрибуты дикта класса, отображающие идентификаторы GUID для существующих экземпляров (вероятно, в качестве слабо значимого диктанта, позволяющего избежать ненужного поддержания экземпляров в живых, но это является побочной проблемой), и при необходимости возвращать существующий экземпляр.

Но если изменения должны быть синхронизированы с какой-либо более тонкой гранулярностью, то внезапно это ДЕЙСТВИТЕЛЬНО трудная проблема распределенных вычислений, и спецификации того, что происходит, в каких случаях действительно нужно прибегать с предельной осторожностью (и с большей паранойей, чем есть). присутствует в большинстве из нас - распределенное программирование ОЧЕНЬ сложно, если только несколько простых и доказуемо правильных шаблонов и идиом не соблюдаются фанатично! -).

Если вы можете придумать спецификации для нас, я могу предложить набросок того, как бы я попытался их встретить. Но я не позволю себе угадать спецификации от вашего имени; -).

Редактировать : ОП уточнил, и, похоже, все, что ему нужно, это лучшее понимание того, как контролировать __new__. Это просто: см. __getnewargs__ - вам понадобится класс нового стиля и травление с протоколом 2 или лучше (но это рекомендуется в любом случае по другим причинам! -), затем __getnewargs__ в существующий объект может просто вернуть GUID объекта (который __new__ должен получить в качестве необязательного параметра). Так что __new__ может проверить, присутствует ли GUID в классе memo [[слабое значение ;-)]] (и если да, вернуть соответствующее значение объекта) - если нет (или если GUID не передан, подразумевая, что это не удаление, поэтому необходимо сгенерировать новый GUID), затем создать действительно новый объект (установив его GUID ;-), а также записать его на уровне класса memo.

Кстати, для создания GUID рассмотрите возможность использования модуля uuid в стандартной библиотеке.

Answer 3

Вы можете использовать просто словарь с ключом и значениями в приемнике. И чтобы избежать утечки памяти, используйте WeakKeyDictionary.