--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/symbian-qemu-0.9.1-12/python-win32-2.6.1/lib/bsddb/dbshelve.py Fri Jul 31 15:01:17 2009 +0100
@@ -0,0 +1,370 @@
+#!/bin/env python
+#------------------------------------------------------------------------
+# Copyright (c) 1997-2001 by Total Control Software
+# All Rights Reserved
+#------------------------------------------------------------------------
+#
+# Module Name: dbShelve.py
+#
+# Description: A reimplementation of the standard shelve.py that
+# forces the use of cPickle, and DB.
+#
+# Creation Date: 11/3/97 3:39:04PM
+#
+# License: This is free software. You may use this software for any
+# purpose including modification/redistribution, so long as
+# this header remains intact and that you do not claim any
+# rights of ownership or authorship of this software. This
+# software has been tested, but no warranty is expressed or
+# implied.
+#
+# 13-Dec-2000: Updated to be used with the new bsddb3 package.
+# Added DBShelfCursor class.
+#
+#------------------------------------------------------------------------
+
+"""Manage shelves of pickled objects using bsddb database files for the
+storage.
+"""
+
+#------------------------------------------------------------------------
+
+import cPickle
+import sys
+
+import sys
+absolute_import = (sys.version_info[0] >= 3)
+if absolute_import :
+ # Because this syntaxis is not valid before Python 2.5
+ exec("from . import db")
+else :
+ import db
+
+#At version 2.3 cPickle switched to using protocol instead of bin
+if sys.version_info[:3] >= (2, 3, 0):
+ HIGHEST_PROTOCOL = cPickle.HIGHEST_PROTOCOL
+# In python 2.3.*, "cPickle.dumps" accepts no
+# named parameters. "pickle.dumps" accepts them,
+# so this seems a bug.
+ if sys.version_info[:3] < (2, 4, 0):
+ def _dumps(object, protocol):
+ return cPickle.dumps(object, protocol)
+ else :
+ def _dumps(object, protocol):
+ return cPickle.dumps(object, protocol=protocol)
+
+else:
+ HIGHEST_PROTOCOL = None
+ def _dumps(object, protocol):
+ return cPickle.dumps(object, bin=protocol)
+
+
+if sys.version_info[0:2] <= (2, 5) :
+ try:
+ from UserDict import DictMixin
+ except ImportError:
+ # DictMixin is new in Python 2.3
+ class DictMixin: pass
+ MutableMapping = DictMixin
+else :
+ import collections
+ MutableMapping = collections.MutableMapping
+
+#------------------------------------------------------------------------
+
+
+def open(filename, flags=db.DB_CREATE, mode=0660, filetype=db.DB_HASH,
+ dbenv=None, dbname=None):
+ """
+ A simple factory function for compatibility with the standard
+ shleve.py module. It can be used like this, where key is a string
+ and data is a pickleable object:
+
+ from bsddb import dbshelve
+ db = dbshelve.open(filename)
+
+ db[key] = data
+
+ db.close()
+ """
+ if type(flags) == type(''):
+ sflag = flags
+ if sflag == 'r':
+ flags = db.DB_RDONLY
+ elif sflag == 'rw':
+ flags = 0
+ elif sflag == 'w':
+ flags = db.DB_CREATE
+ elif sflag == 'c':
+ flags = db.DB_CREATE
+ elif sflag == 'n':
+ flags = db.DB_TRUNCATE | db.DB_CREATE
+ else:
+ raise db.DBError, "flags should be one of 'r', 'w', 'c' or 'n' or use the bsddb.db.DB_* flags"
+
+ d = DBShelf(dbenv)
+ d.open(filename, dbname, filetype, flags, mode)
+ return d
+
+#---------------------------------------------------------------------------
+
+class DBShelveError(db.DBError): pass
+
+
+class DBShelf(MutableMapping):
+ """A shelf to hold pickled objects, built upon a bsddb DB object. It
+ automatically pickles/unpickles data objects going to/from the DB.
+ """
+ def __init__(self, dbenv=None):
+ self.db = db.DB(dbenv)
+ self._closed = True
+ if HIGHEST_PROTOCOL:
+ self.protocol = HIGHEST_PROTOCOL
+ else:
+ self.protocol = 1
+
+
+ def __del__(self):
+ self.close()
+
+
+ def __getattr__(self, name):
+ """Many methods we can just pass through to the DB object.
+ (See below)
+ """
+ return getattr(self.db, name)
+
+
+ #-----------------------------------
+ # Dictionary access methods
+
+ def __len__(self):
+ return len(self.db)
+
+
+ def __getitem__(self, key):
+ data = self.db[key]
+ return cPickle.loads(data)
+
+
+ def __setitem__(self, key, value):
+ data = _dumps(value, self.protocol)
+ self.db[key] = data
+
+
+ def __delitem__(self, key):
+ del self.db[key]
+
+
+ def keys(self, txn=None):
+ if txn != None:
+ return self.db.keys(txn)
+ else:
+ return self.db.keys()
+
+ if sys.version_info[0:2] >= (2, 6) :
+ def __iter__(self) :
+ return self.db.__iter__()
+
+
+ def open(self, *args, **kwargs):
+ self.db.open(*args, **kwargs)
+ self._closed = False
+
+
+ def close(self, *args, **kwargs):
+ self.db.close(*args, **kwargs)
+ self._closed = True
+
+
+ def __repr__(self):
+ if self._closed:
+ return '<DBShelf @ 0x%x - closed>' % (id(self))
+ else:
+ return repr(dict(self.iteritems()))
+
+
+ def items(self, txn=None):
+ if txn != None:
+ items = self.db.items(txn)
+ else:
+ items = self.db.items()
+ newitems = []
+
+ for k, v in items:
+ newitems.append( (k, cPickle.loads(v)) )
+ return newitems
+
+ def values(self, txn=None):
+ if txn != None:
+ values = self.db.values(txn)
+ else:
+ values = self.db.values()
+
+ return map(cPickle.loads, values)
+
+ #-----------------------------------
+ # Other methods
+
+ def __append(self, value, txn=None):
+ data = _dumps(value, self.protocol)
+ return self.db.append(data, txn)
+
+ def append(self, value, txn=None):
+ if self.get_type() == db.DB_RECNO:
+ return self.__append(value, txn=txn)
+ raise DBShelveError, "append() only supported when dbshelve opened with filetype=dbshelve.db.DB_RECNO"
+
+
+ def associate(self, secondaryDB, callback, flags=0):
+ def _shelf_callback(priKey, priData, realCallback=callback):
+ # Safe in Python 2.x because expresion short circuit
+ if sys.version_info[0] < 3 or isinstance(priData, bytes) :
+ data = cPickle.loads(priData)
+ else :
+ data = cPickle.loads(bytes(priData, "iso8859-1")) # 8 bits
+ return realCallback(priKey, data)
+
+ return self.db.associate(secondaryDB, _shelf_callback, flags)
+
+
+ #def get(self, key, default=None, txn=None, flags=0):
+ def get(self, *args, **kw):
+ # We do it with *args and **kw so if the default value wasn't
+ # given nothing is passed to the extension module. That way
+ # an exception can be raised if set_get_returns_none is turned
+ # off.
+ data = apply(self.db.get, args, kw)
+ try:
+ return cPickle.loads(data)
+ except (EOFError, TypeError, cPickle.UnpicklingError):
+ return data # we may be getting the default value, or None,
+ # so it doesn't need unpickled.
+
+ def get_both(self, key, value, txn=None, flags=0):
+ data = _dumps(value, self.protocol)
+ data = self.db.get(key, data, txn, flags)
+ return cPickle.loads(data)
+
+
+ def cursor(self, txn=None, flags=0):
+ c = DBShelfCursor(self.db.cursor(txn, flags))
+ c.protocol = self.protocol
+ return c
+
+
+ def put(self, key, value, txn=None, flags=0):
+ data = _dumps(value, self.protocol)
+ return self.db.put(key, data, txn, flags)
+
+
+ def join(self, cursorList, flags=0):
+ raise NotImplementedError
+
+
+ #----------------------------------------------
+ # Methods allowed to pass-through to self.db
+ #
+ # close, delete, fd, get_byteswapped, get_type, has_key,
+ # key_range, open, remove, rename, stat, sync,
+ # upgrade, verify, and all set_* methods.
+
+
+#---------------------------------------------------------------------------
+
+class DBShelfCursor:
+ """
+ """
+ def __init__(self, cursor):
+ self.dbc = cursor
+
+ def __del__(self):
+ self.close()
+
+
+ def __getattr__(self, name):
+ """Some methods we can just pass through to the cursor object. (See below)"""
+ return getattr(self.dbc, name)
+
+
+ #----------------------------------------------
+
+ def dup(self, flags=0):
+ c = DBShelfCursor(self.dbc.dup(flags))
+ c.protocol = self.protocol
+ return c
+
+
+ def put(self, key, value, flags=0):
+ data = _dumps(value, self.protocol)
+ return self.dbc.put(key, data, flags)
+
+
+ def get(self, *args):
+ count = len(args) # a method overloading hack
+ method = getattr(self, 'get_%d' % count)
+ apply(method, args)
+
+ def get_1(self, flags):
+ rec = self.dbc.get(flags)
+ return self._extract(rec)
+
+ def get_2(self, key, flags):
+ rec = self.dbc.get(key, flags)
+ return self._extract(rec)
+
+ def get_3(self, key, value, flags):
+ data = _dumps(value, self.protocol)
+ rec = self.dbc.get(key, flags)
+ return self._extract(rec)
+
+
+ def current(self, flags=0): return self.get_1(flags|db.DB_CURRENT)
+ def first(self, flags=0): return self.get_1(flags|db.DB_FIRST)
+ def last(self, flags=0): return self.get_1(flags|db.DB_LAST)
+ def next(self, flags=0): return self.get_1(flags|db.DB_NEXT)
+ def prev(self, flags=0): return self.get_1(flags|db.DB_PREV)
+ def consume(self, flags=0): return self.get_1(flags|db.DB_CONSUME)
+ def next_dup(self, flags=0): return self.get_1(flags|db.DB_NEXT_DUP)
+ def next_nodup(self, flags=0): return self.get_1(flags|db.DB_NEXT_NODUP)
+ def prev_nodup(self, flags=0): return self.get_1(flags|db.DB_PREV_NODUP)
+
+
+ def get_both(self, key, value, flags=0):
+ data = _dumps(value, self.protocol)
+ rec = self.dbc.get_both(key, flags)
+ return self._extract(rec)
+
+
+ def set(self, key, flags=0):
+ rec = self.dbc.set(key, flags)
+ return self._extract(rec)
+
+ def set_range(self, key, flags=0):
+ rec = self.dbc.set_range(key, flags)
+ return self._extract(rec)
+
+ def set_recno(self, recno, flags=0):
+ rec = self.dbc.set_recno(recno, flags)
+ return self._extract(rec)
+
+ set_both = get_both
+
+ def _extract(self, rec):
+ if rec is None:
+ return None
+ else:
+ key, data = rec
+ # Safe in Python 2.x because expresion short circuit
+ if sys.version_info[0] < 3 or isinstance(data, bytes) :
+ return key, cPickle.loads(data)
+ else :
+ return key, cPickle.loads(bytes(data, "iso8859-1")) # 8 bits
+
+ #----------------------------------------------
+ # Methods allowed to pass-through to self.dbc
+ #
+ # close, count, delete, get_recno, join_item
+
+
+#---------------------------------------------------------------------------