cpython/Lib/shelve.py

165 lines
4.6 KiB
Python
Raw Normal View History

1995-02-09 13:18:10 -04:00
"""Manage shelves of pickled objects.
A "shelf" is a persistent, dictionary-like object. The difference
with dbm databases is that the values (not the keys!) in a shelf can
be essentially arbitrary Python objects -- anything that the "pickle"
module can handle. This includes most class instances, recursive data
types, and objects containing lots of shared sub-objects. The keys
are ordinary strings.
To summarize the interface (key is a string, data is an arbitrary
object):
2000-02-10 13:17:14 -04:00
import shelve
d = shelve.open(filename) # open, with (g)dbm filename -- no suffix
1995-02-09 13:18:10 -04:00
2000-02-10 13:17:14 -04:00
d[key] = data # store data at key (overwrites old data if
# using an existing key)
data = d[key] # retrieve data at key (raise KeyError if no
# such key)
del d[key] # delete data stored at key (raises KeyError
# if no such key)
2002-10-18 05:58:14 -03:00
flag = d.has_key(key) # true if the key exists; same as "key in d"
2000-02-10 13:17:14 -04:00
list = d.keys() # a list of all existing keys (slow!)
1995-02-09 13:18:10 -04:00
2000-02-10 13:17:14 -04:00
d.close() # close it
1995-02-09 13:18:10 -04:00
Dependent on the implementation, closing a persistent dictionary may
or may not be necessary to flush changes to disk.
"""
# Try using cPickle and cStringIO if available.
try:
2001-01-14 21:36:40 -04:00
from cPickle import Pickler, Unpickler
except ImportError:
2001-01-14 21:36:40 -04:00
from pickle import Pickler, Unpickler
try:
2001-01-14 21:36:40 -04:00
from cStringIO import StringIO
except ImportError:
2001-01-14 21:36:40 -04:00
from StringIO import StringIO
import UserDict
__all__ = ["Shelf","BsdDbShelf","DbfilenameShelf","open"]
1995-02-09 13:18:10 -04:00
class Shelf(UserDict.DictMixin):
2001-01-14 21:36:40 -04:00
"""Base class for shelf implementations.
This is initialized with a dictionary-like object.
See the module's __doc__ string for an overview of the interface.
"""
def __init__(self, dict, binary=False):
2001-01-14 21:36:40 -04:00
self.dict = dict
self._binary = binary
2001-01-14 21:36:40 -04:00
def keys(self):
return self.dict.keys()
def __len__(self):
return len(self.dict)
def has_key(self, key):
return self.dict.has_key(key)
2002-10-18 05:58:14 -03:00
def __contains__(self, key):
return self.dict.has_key(key)
2001-01-14 21:36:40 -04:00
def get(self, key, default=None):
if self.dict.has_key(key):
return self[key]
return default
def __getitem__(self, key):
f = StringIO(self.dict[key])
return Unpickler(f).load()
def __setitem__(self, key, value):
f = StringIO()
p = Pickler(f, self._binary)
2001-01-14 21:36:40 -04:00
p.dump(value)
self.dict[key] = f.getvalue()
def __delitem__(self, key):
del self.dict[key]
def close(self):
try:
self.dict.close()
except:
pass
self.dict = 0
def __del__(self):
self.close()
def sync(self):
if hasattr(self.dict, 'sync'):
self.dict.sync()
1995-02-09 13:18:10 -04:00
class BsdDbShelf(Shelf):
2001-01-14 21:36:40 -04:00
"""Shelf implementation using the "BSD" db interface.
2001-01-14 21:36:40 -04:00
This adds methods first(), next(), previous(), last() and
set_location() that have no counterpart in [g]dbm databases.
2001-01-14 21:36:40 -04:00
The actual database must be opened using one of the "bsddb"
modules "open" routines (i.e. bsddb.hashopen, bsddb.btopen or
bsddb.rnopen) and passed to the constructor.
2001-01-14 21:36:40 -04:00
See the module's __doc__ string for an overview of the interface.
"""
def __init__(self, dict, binary=False):
Shelf.__init__(self, dict, binary)
2001-01-14 21:36:40 -04:00
def set_location(self, key):
(key, value) = self.dict.set_location(key)
f = StringIO(value)
return (key, Unpickler(f).load())
2001-01-14 21:36:40 -04:00
def next(self):
(key, value) = self.dict.next()
f = StringIO(value)
return (key, Unpickler(f).load())
2001-01-14 21:36:40 -04:00
def previous(self):
(key, value) = self.dict.previous()
f = StringIO(value)
return (key, Unpickler(f).load())
2001-01-14 21:36:40 -04:00
def first(self):
(key, value) = self.dict.first()
f = StringIO(value)
return (key, Unpickler(f).load())
2001-01-14 21:36:40 -04:00
def last(self):
(key, value) = self.dict.last()
f = StringIO(value)
return (key, Unpickler(f).load())
class DbfilenameShelf(Shelf):
2001-01-14 21:36:40 -04:00
"""Shelf implementation using the "anydbm" generic dbm interface.
This is initialized with the filename for the dbm database.
See the module's __doc__ string for an overview of the interface.
"""
1995-02-09 13:18:10 -04:00
def __init__(self, filename, flag='c', binary=False):
2001-01-14 21:36:40 -04:00
import anydbm
Shelf.__init__(self, anydbm.open(filename, flag), binary)
1995-02-09 13:18:10 -04:00
def open(filename, flag='c', binary=False):
2001-01-14 21:36:40 -04:00
"""Open a persistent dictionary for reading and writing.
Argument is the filename for the dbm database.
See the module's __doc__ string for an overview of the interface.
"""
1995-02-09 13:18:10 -04:00
return DbfilenameShelf(filename, flag, binary)