Update with pickle

[Nicolas Fleury]

Is it possible to use the pickle module to update an object instead of
creating a new instance?
Thx
Nicolas

[Matteo Dell'Amico]

Nicolas Fleury wrote:

Is it possible to use the pickle module to update an object instead of
creating a new instance?

I don't get what you want to do. Can you explain yourself better? What
do you mean by "updating" an object?

--
Ciao,
Matteo

[Nicolas Fleury]

Matteo Dell'Amico wrote:

Nicolas Fleury wrote:

Is it possible to use the pickle module to update an object instead of
creating a new instance?

I don't get what you want to do. Can you explain yourself better? What
do you mean by "updating" an object?

Use the same reference instead of creating a new instance. Basically
making pickle call __init__ of an existing object. The best solution I
see for now is to copy the __dict__ of the new object to the existing
one. I want to update the content of an object with a dumped object of
the same type so that all reference to existing object are still valid.

Regards,
Nicolas

[Matteo Dell'Amico]

Nicolas Fleury wrote:

I don't get what you want to do. Can you explain yourself better? What
do you mean by "updating" an object?

Use the same reference instead of creating a new instance. Basically
making pickle call __init__ of an existing object. The best solution I
see for now is to copy the __dict__ of the new object to the existing
one. I want to update the content of an object with a dumped object of
the same type so that all reference to existing object are still valid.

I think it's not possible to do automatically. Beware of copying
__dict__, since starting with python 2.2, it's possible to have data
that doesn't reside in __dict__, for instance when using __slots__.

I guess you have to find a way to encapsulate information, and maybe a
proxy could be OK for you (I can't find the recipe in the Python
Cookbook right now, since it appears to be down). That way, you could
keep all references to the proxy, and change the encapsulated data when
you need it.

--
Ciao,
Matteo

[Leif K-Brooks]

Nicolas Fleury wrote:

I want to update the content of an object with a dumped object of the
same type so that all reference to existing object are still valid.

Add interfaces to your object's class for mutability rather than using a
low-level hack. Something like this (untested):
class cls(object):
__slots__ = ('foo')
def __init__(self, foo=None):
self.foo = foo

def set_foo(self, foo):
self.foo = foo
foo = cls(42)
bar = foo
print bar.foo # 42
foo.set_foo(43)
print bar.foo # 43

[Nicolas Fleury]

Leif K-Brooks wrote:

Nicolas Fleury wrote:

I want to update the content of an object with a dumped object of the
same type so that all reference to existing object are still valid.

Add interfaces to your object's class for mutability rather than using a
low-level hack. Something like this (untested):

Thx for your answer, but according to what I read about __slots__, this
feature has never been intended to be used that way either, so it's also
a kinda low-level hack, no? It is still an interesting solution.

Regards,
Nicolas

[Leif K-Brooks]

Nicolas Fleury wrote:

Leif K-Brooks wrote:

Add interfaces to your object's class for mutability rather than using
a low-level hack. Something like this (untested):

Thx for your answer, but according to what I read about __slots__, this
feature has never been intended to be used that way either, so it's also
a kinda low-level hack, no? It is still an interesting solution.

Using __slots__ is just an optimization, it isn't directly related to
the example. This would also work:
class cls:
def __init__(self, foo=None):
self.foo = foo

def set_foo(self, foo):
self.foo = foo
foo = cls(42)
bar = foo
print bar.foo # 42
foo.set_foo(43)
print bar.foo # 43

[Stefan Seefeld]

Hi there (,hi Nicolas !),

I'v been looking for something similar recently,
so this thread caught my attention, but...

Leif K-Brooks wrote:

Using __slots__ is just an optimization, it isn't directly related to
the example. This would also work:
class cls:
def __init__(self, foo=None):
self.foo = foo

def set_foo(self, foo):
self.foo = foo
foo = cls(42)
bar = foo
print bar.foo # 42
foo.set_foo(43)
print bar.foo # 43

....I'm still lost: how is this interface-enriched declaration helping
in the task to retrieve ('internalize') an object's state from a pickle ?

Even if I set the object's state via some 'set' manipulators, I still have
to retrieve the state from the pickle and identify the object it is targetted at.

Looking again into the docs for the pickle protocol, I wonder whether there
isn't any place in the __init__/__reduce__/__setstate__ magic to throw in
some meta-programming (i.e. an intelligent metaclass doing the job), or providing
a clever __new__ operator that doesn't return a new object but an existing one,
etc., etc.

Regards,
Stefan

[Matteo Dell'Amico]

Matteo Dell'Amico wrote:

I guess you have to find a way to encapsulate information, and maybe a
proxy could be OK for you (I can't find the recipe in the Python
Cookbook right now, since it appears to be down).

Now it works again. Have a look at
http://aspn.activestate.com/ASPN/Coo.../Recipe/252151 . You
can, without problems, save _obj and then restore it with pickle.
I think this solves your problem.

--
Ciao,
Matteo

[Nicolas Fleury]

Stefan Seefeld wrote:

Hi there (,hi Nicolas !), ...I'm still lost: how is this interface-enriched declaration helping
in the task to retrieve ('internalize') an object's state from a pickle ?
Hi Stefan,
You're right, the example shows how to copy and it creates a new
reference, so it doesn't help in the problem (I realized it when going
back home yesterday).
Looking again into the docs for the pickle protocol, I wonder whether there
isn't any place in the __init__/__reduce__/__setstate__ magic to throw in
some meta-programming (i.e. an intelligent metaclass doing the job), or
providing
a clever __new__ operator that doesn't return a new object but an
existing one,
etc., etc.

I just added a feature request on sf to have an updating load function
in pickle. My preferred solution for now might still be the copy of
__dict__ (I could copy slots also), it's simple and not intrusive (using
proxies is, even if less a hack). However, the cleanest solution would
be to implement your solution, but I have no idea how to do it for now.

Regards,
Nicolas