home *** CD-ROM | disk | FTP | other *** search
/ Personal Computer World 2009 February / PCWFEB09.iso / Software / Linux / Kubuntu 8.10 / kubuntu-8.10-desktop-i386.iso / casper / filesystem.squashfs / usr / lib / python2.5 / bsddb / dbshelve.pyc (.txt) < prev    next >
Encoding:
Python Compiled Bytecode  |  2008-10-29  |  10.9 KB  |  289 lines
  1. # Source Generated with Decompyle++
  2. # File: in.pyc (Python 2.5)
  3.  
  4. '''Manage shelves of pickled objects using bsddb database files for the
  5. storage.
  6. '''
  7. import cPickle
  8.  
  9. try:
  10.     from UserDict import DictMixin
  11. except ImportError:
  12.     
  13.     class DictMixin:
  14.         pass
  15.  
  16.  
  17. import db
  18.  
  19. def open(filename, flags = db.DB_CREATE, mode = 432, filetype = db.DB_HASH, dbenv = None, dbname = None):
  20.     '''
  21.     A simple factory function for compatibility with the standard
  22.     shleve.py module.  It can be used like this, where key is a string
  23.     and data is a pickleable object:
  24.  
  25.         from bsddb import dbshelve
  26.         db = dbshelve.open(filename)
  27.  
  28.         db[key] = data
  29.  
  30.         db.close()
  31.     '''
  32.     if type(flags) == type(''):
  33.         sflag = flags
  34.         if sflag == 'r':
  35.             flags = db.DB_RDONLY
  36.         elif sflag == 'rw':
  37.             flags = 0
  38.         elif sflag == 'w':
  39.             flags = db.DB_CREATE
  40.         elif sflag == 'c':
  41.             flags = db.DB_CREATE
  42.         elif sflag == 'n':
  43.             flags = db.DB_TRUNCATE | db.DB_CREATE
  44.         else:
  45.             raise db.DBError, "flags should be one of 'r', 'w', 'c' or 'n' or use the bsddb.db.DB_* flags"
  46.     
  47.     d = DBShelf(dbenv)
  48.     d.open(filename, dbname, filetype, flags, mode)
  49.     return d
  50.  
  51.  
  52. class DBShelveError(db.DBError):
  53.     pass
  54.  
  55.  
  56. class DBShelf(DictMixin):
  57.     '''A shelf to hold pickled objects, built upon a bsddb DB object.  It
  58.     automatically pickles/unpickles data objects going to/from the DB.
  59.     '''
  60.     
  61.     def __init__(self, dbenv = None):
  62.         self.db = db.DB(dbenv)
  63.         self.binary = 1
  64.  
  65.     
  66.     def __del__(self):
  67.         self.close()
  68.  
  69.     
  70.     def __getattr__(self, name):
  71.         '''Many methods we can just pass through to the DB object.
  72.         (See below)
  73.         '''
  74.         return getattr(self.db, name)
  75.  
  76.     
  77.     def __len__(self):
  78.         return len(self.db)
  79.  
  80.     
  81.     def __getitem__(self, key):
  82.         data = self.db[key]
  83.         return cPickle.loads(data)
  84.  
  85.     
  86.     def __setitem__(self, key, value):
  87.         data = cPickle.dumps(value, self.binary)
  88.         self.db[key] = data
  89.  
  90.     
  91.     def __delitem__(self, key):
  92.         del self.db[key]
  93.  
  94.     
  95.     def keys(self, txn = None):
  96.         if txn != None:
  97.             return self.db.keys(txn)
  98.         else:
  99.             return self.db.keys()
  100.  
  101.     
  102.     def items(self, txn = None):
  103.         if txn != None:
  104.             items = self.db.items(txn)
  105.         else:
  106.             items = self.db.items()
  107.         newitems = []
  108.         for k, v in items:
  109.             newitems.append((k, cPickle.loads(v)))
  110.         
  111.         return newitems
  112.  
  113.     
  114.     def values(self, txn = None):
  115.         if txn != None:
  116.             values = self.db.values(txn)
  117.         else:
  118.             values = self.db.values()
  119.         return map(cPickle.loads, values)
  120.  
  121.     
  122.     def __append(self, value, txn = None):
  123.         data = cPickle.dumps(value, self.binary)
  124.         return self.db.append(data, txn)
  125.  
  126.     
  127.     def append(self, value, txn = None):
  128.         if self.get_type() == db.DB_RECNO:
  129.             return self._DBShelf__append(value, txn = txn)
  130.         
  131.         raise DBShelveError, 'append() only supported when dbshelve opened with filetype=dbshelve.db.DB_RECNO'
  132.  
  133.     
  134.     def associate(self, secondaryDB, callback, flags = 0):
  135.         
  136.         def _shelf_callback(priKey, priData, realCallback = callback):
  137.             data = cPickle.loads(priData)
  138.             return realCallback(priKey, data)
  139.  
  140.         return self.db.associate(secondaryDB, _shelf_callback, flags)
  141.  
  142.     
  143.     def get(self, *args, **kw):
  144.         data = apply(self.db.get, args, kw)
  145.         
  146.         try:
  147.             return cPickle.loads(data)
  148.         except (TypeError, cPickle.UnpicklingError):
  149.             return data
  150.  
  151.  
  152.     
  153.     def get_both(self, key, value, txn = None, flags = 0):
  154.         data = cPickle.dumps(value, self.binary)
  155.         data = self.db.get(key, data, txn, flags)
  156.         return cPickle.loads(data)
  157.  
  158.     
  159.     def cursor(self, txn = None, flags = 0):
  160.         c = DBShelfCursor(self.db.cursor(txn, flags))
  161.         c.binary = self.binary
  162.         return c
  163.  
  164.     
  165.     def put(self, key, value, txn = None, flags = 0):
  166.         data = cPickle.dumps(value, self.binary)
  167.         return self.db.put(key, data, txn, flags)
  168.  
  169.     
  170.     def join(self, cursorList, flags = 0):
  171.         raise NotImplementedError
  172.  
  173.  
  174.  
  175. class DBShelfCursor:
  176.     '''
  177.     '''
  178.     
  179.     def __init__(self, cursor):
  180.         self.dbc = cursor
  181.  
  182.     
  183.     def __del__(self):
  184.         self.close()
  185.  
  186.     
  187.     def __getattr__(self, name):
  188.         '''Some methods we can just pass through to the cursor object.  (See below)'''
  189.         return getattr(self.dbc, name)
  190.  
  191.     
  192.     def dup(self, flags = 0):
  193.         return DBShelfCursor(self.dbc.dup(flags))
  194.  
  195.     
  196.     def put(self, key, value, flags = 0):
  197.         data = cPickle.dumps(value, self.binary)
  198.         return self.dbc.put(key, data, flags)
  199.  
  200.     
  201.     def get(self, *args):
  202.         count = len(args)
  203.         method = getattr(self, 'get_%d' % count)
  204.         apply(method, args)
  205.  
  206.     
  207.     def get_1(self, flags):
  208.         rec = self.dbc.get(flags)
  209.         return self._extract(rec)
  210.  
  211.     
  212.     def get_2(self, key, flags):
  213.         rec = self.dbc.get(key, flags)
  214.         return self._extract(rec)
  215.  
  216.     
  217.     def get_3(self, key, value, flags):
  218.         data = cPickle.dumps(value, self.binary)
  219.         rec = self.dbc.get(key, flags)
  220.         return self._extract(rec)
  221.  
  222.     
  223.     def current(self, flags = 0):
  224.         return self.get_1(flags | db.DB_CURRENT)
  225.  
  226.     
  227.     def first(self, flags = 0):
  228.         return self.get_1(flags | db.DB_FIRST)
  229.  
  230.     
  231.     def last(self, flags = 0):
  232.         return self.get_1(flags | db.DB_LAST)
  233.  
  234.     
  235.     def next(self, flags = 0):
  236.         return self.get_1(flags | db.DB_NEXT)
  237.  
  238.     
  239.     def prev(self, flags = 0):
  240.         return self.get_1(flags | db.DB_PREV)
  241.  
  242.     
  243.     def consume(self, flags = 0):
  244.         return self.get_1(flags | db.DB_CONSUME)
  245.  
  246.     
  247.     def next_dup(self, flags = 0):
  248.         return self.get_1(flags | db.DB_NEXT_DUP)
  249.  
  250.     
  251.     def next_nodup(self, flags = 0):
  252.         return self.get_1(flags | db.DB_NEXT_NODUP)
  253.  
  254.     
  255.     def prev_nodup(self, flags = 0):
  256.         return self.get_1(flags | db.DB_PREV_NODUP)
  257.  
  258.     
  259.     def get_both(self, key, value, flags = 0):
  260.         data = cPickle.dumps(value, self.binary)
  261.         rec = self.dbc.get_both(key, flags)
  262.         return self._extract(rec)
  263.  
  264.     
  265.     def set(self, key, flags = 0):
  266.         rec = self.dbc.set(key, flags)
  267.         return self._extract(rec)
  268.  
  269.     
  270.     def set_range(self, key, flags = 0):
  271.         rec = self.dbc.set_range(key, flags)
  272.         return self._extract(rec)
  273.  
  274.     
  275.     def set_recno(self, recno, flags = 0):
  276.         rec = self.dbc.set_recno(recno, flags)
  277.         return self._extract(rec)
  278.  
  279.     set_both = get_both
  280.     
  281.     def _extract(self, rec):
  282.         if rec is None:
  283.             return None
  284.         else:
  285.             (key, data) = rec
  286.             return (key, cPickle.loads(data))
  287.  
  288.  
  289.