pickle an instance of a custom class

[PBlitz]

I want to save the content of a custom made OrderedDict. (I got the OrderedDict from http://aspn.activestate.com/ASPN/Python)
The pickle modul seemed to be the solution for the job.
At first I tried to pickle the "nacked" OrderedDict derived from dict, but the pickle routine saves only a empty dict. A secont try to "replace" the __dict__ with the __getstate__ and __setstate__ methods also faild.

How can I save the content (the items of the derived dict and the _keys list) of the OrderedDict via the pickle modul?

here is the code:

class OrderedDict(dict):
    """This dictionary class extends UserDict to record the order in which items are 
    added. Calling keys(), values(), items(), etc. will return results in this order."""
 
    def __init__(self, d = None):
        self._keys = []
        if d == None: d = {}
        self.update(d)
 
    def __setitem__(self, key, item):
        dict.__setitem__(self,key, item)
        if key not in self._keys: self._keys.append(key)
 
    def items(self):
        return zip(self._keys, self.values())
 
    def keys(self):
        return self._keys[:]
 
    def update(self, d):
        dict.update(self, d)
        for key in d.keys():
            if key not in self._keys: self._keys.append(key)
 
    def __getstate__(self):
        """Return state values to be pickled."""
        return (dict(self.items()), self._keys)
 
    def __setstate__(self, state):
        """Restore state from the unpickled state values."""
        self.update(state[0])
        self._keys = state[1]
 
if __name__ == "__main__":
    import pickle
    o = OrderedDict()
    o['a'] = [0,1]
    o['b'] = [2,3]
    p = pickle.dumps(o)
    u = pickle.loads(p)
    print o # output should be {'b': [2, 3], 'a': [0, 1]}
    print u # output should be {'b': [2, 3], 'a': [0, 1]}
 
# Output:
#{'b': [2, 3], 'a': [0, 1]}
#{}                                      
 

[bvdet]

I want to save the content of a custom made OrderedDict. (I got the OrderedDict from http://aspn.activestate.com/ASPN/Python)
The pickle modul seemed to be the solution for the job.
At first I tried to pickle the "nacked" OrderedDict derived from dict, but the pickle routine saves only a empty dict. A secont try to "replace" the __dict__ with the __getstate__ and __setstate__ methods also faild.

How can I save the content (the items of the derived dict and the _keys list) of the OrderedDict via the pickle modul?

The dictionary elements will display in the correct order if you implement a __repr__() method. You will also need to override the dict.values() method so the values will be paired with the correct keys. Object pickling and unpickling should work without __getstate__() and __setstate__() methods.

class OrderedDict(dict):
 
    def __init__(self, d = None):
        self._keys = []
        if d == None: d = {}
        self.update(d)
 
    def __setitem__(self, key, item):
        dict.__setitem__(self,key, item)
        if key not in self._keys: self._keys.append(key)
 
    def items(self):
        return zip(self._keys, self.values())
 
    def keys(self):
        return self._keys[:]
 
    def itervalues(self):
        for k in self._keys:
            yield self[k]
 
    def values(self):
        return list(self.itervalues())    
 
    def update(self, d):
        dict.update(self, d)
        for key in d.keys():
            if key not in self._keys: self._keys.append(key)
 
    def __repr__(self):
        return '{%s}' % ', '.join([': '.join([repr(k),str(v)]) \
                                   for k,v in zip(self.keys(), self.values())])
 
if __name__ == "__main__":
    dd = OrderedDict()
    dd['z'] = [0,1]
    dd['b'] = [2,3]
    dd['x'] = [21,22]
    dd['y'] = [45,46]
    dd['a'] = [9,10]
    p = pickle.dumps(dd)
    u = pickle.loads(p)
    print dd
    print u

Output:

>>> {'z': [0, 1], 'b': [2, 3], 'x': [21, 22], 'y': [45, 46], 'a': [9, 10]}
{'z': [0, 1], 'b': [2, 3], 'x': [21, 22], 'y': [45, 46], 'a': [9, 10]}
>>>

[PBlitz]

Thank you for the help. Unfortunately my output with your code is:
{'z': [0, 1], 'b': [2, 3], 'x': [21, 22], 'y': [45, 46], 'a': [9, 10]}
{}

the pickle p contains:
c__main__
OrderedDict
p0
(tp1
Rp2
.

This means the pickle dumps no dict values nor _keys list values.
Maybe the reason is my configuration. I use jython 2.2.1 on a windows machine.
Is there a implementation difference between python and jython?

[bvdet]

Thank you for the help. Unfortunately my output with your code is:
{'z': [0, 1], 'b': [2, 3], 'x': [21, 22], 'y': [45, 46], 'a': [9, 10]}
{}

the pickle p contains:
c__main__
OrderedDict
p0
(tp1
Rp2
.

This means the pickle dumps no dict values nor _keys list values.
Maybe the reason is my configuration. I use jython 2.2.1 on a windows machine.
Is there a implementation difference between python and jython?

I am using Python 2.3 on Windows XP. I don't know the differences. I have pickled class instances successfully many times. Your pickle module may be broken.

[PBlitz]

Here a more precise description of the issue:
Pickling of a class derived from dict creates an empty pickle in jython
2.2.1. In contrast Python 2.5.2 delivers the expected result.
So I assume a bug in the jython pickle module. Does anyone know if a developer release of jython already solves the problem? Or how to patch the module?

# code describing the issue:

class MyDict(dict):
    def __init__(self, d = None):
        if d == None: d = {}
        dict.__init__(self, d)
 
if __name__ == "__main__":
    import pickle
    md = MyDict({'b': [2, 3], 'z': [0, 1]})
    p = pickle.dumps(md)
    rd = pickle.loads(p)
    print "-> pickle p:\n", p
    print "-> MyDict md:\n", md
    print "-> reconstructed MyDict rd:\n", rd
 

# jython 2.2.1 output with empty pickle p:

-> pickle p:
c__main__
MyDict
p0
(tp1
Rp2
.
-> MyDict md:
{'b': [2, 3], 'z': [0, 1]}
-> reconstructed MyDict rd:
{}

# in contrast python 2.5.2 output with filled pickle p:

-> pickle p:
ccopy_reg
_reconstructor
p0
(c__main__
MyDict
p1
c__builtin__
dict
p2
(dp3
S'b'
p4
(lp5
I2
aI3
asS'z'
p6
(lp7
I0
aI1
astp8
Rp9
.
-> MyDict md:
{'b': [2, 3], 'z': [0, 1]}
-> reconstructed MyDict rd:
{'b': [2, 3], 'z': [0, 1]}