home *** CD-ROM | disk | FTP | other *** search
/ Personal Computer World 2007 September / PCWSEP07.iso / Software / Linux / Linux Mint 3.0 Light / LinuxMint-3.0-Light.iso / casper / filesystem.squashfs / usr / lib / python2.5 / bsddb / dbshelve.pyc (.txt) < prev    next >
Encoding:
Python Compiled Bytecode  |  2007-05-11  |  9.9 KB  |  286 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 DBShelf(DictMixin):
  53.     '''A shelf to hold pickled objects, built upon a bsddb DB object.  It
  54.     automatically pickles/unpickles data objects going to/from the DB.
  55.     '''
  56.     
  57.     def __init__(self, dbenv = None):
  58.         self.db = db.DB(dbenv)
  59.         self.binary = 1
  60.  
  61.     
  62.     def __del__(self):
  63.         self.close()
  64.  
  65.     
  66.     def __getattr__(self, name):
  67.         '''Many methods we can just pass through to the DB object.
  68.         (See below)
  69.         '''
  70.         return getattr(self.db, name)
  71.  
  72.     
  73.     def __len__(self):
  74.         return len(self.db)
  75.  
  76.     
  77.     def __getitem__(self, key):
  78.         data = self.db[key]
  79.         return cPickle.loads(data)
  80.  
  81.     
  82.     def __setitem__(self, key, value):
  83.         data = cPickle.dumps(value, self.binary)
  84.         self.db[key] = data
  85.  
  86.     
  87.     def __delitem__(self, key):
  88.         del self.db[key]
  89.  
  90.     
  91.     def keys(self, txn = None):
  92.         if txn != None:
  93.             return self.db.keys(txn)
  94.         else:
  95.             return self.db.keys()
  96.  
  97.     
  98.     def items(self, txn = None):
  99.         if txn != None:
  100.             items = self.db.items(txn)
  101.         else:
  102.             items = self.db.items()
  103.         newitems = []
  104.         for k, v in items:
  105.             newitems.append((k, cPickle.loads(v)))
  106.         
  107.         return newitems
  108.  
  109.     
  110.     def values(self, txn = None):
  111.         if txn != None:
  112.             values = self.db.values(txn)
  113.         else:
  114.             values = self.db.values()
  115.         return map(cPickle.loads, values)
  116.  
  117.     
  118.     def __append(self, value, txn = None):
  119.         data = cPickle.dumps(value, self.binary)
  120.         return self.db.append(data, txn)
  121.  
  122.     
  123.     def append(self, value, txn = None):
  124.         if self.get_type() != db.DB_RECNO:
  125.             self.append = self._DBShelf__append
  126.             return self.append(value, txn = txn)
  127.         
  128.         raise db.DBError, 'append() only supported when dbshelve opened with filetype=dbshelve.db.DB_RECNO'
  129.  
  130.     
  131.     def associate(self, secondaryDB, callback, flags = 0):
  132.         
  133.         def _shelf_callback(priKey, priData, realCallback = callback):
  134.             data = cPickle.loads(priData)
  135.             return realCallback(priKey, data)
  136.  
  137.         return self.db.associate(secondaryDB, _shelf_callback, flags)
  138.  
  139.     
  140.     def get(self, *args, **kw):
  141.         data = apply(self.db.get, args, kw)
  142.         
  143.         try:
  144.             return cPickle.loads(data)
  145.         except (TypeError, cPickle.UnpicklingError):
  146.             return data
  147.  
  148.  
  149.     
  150.     def get_both(self, key, value, txn = None, flags = 0):
  151.         data = cPickle.dumps(value, self.binary)
  152.         data = self.db.get(key, data, txn, flags)
  153.         return cPickle.loads(data)
  154.  
  155.     
  156.     def cursor(self, txn = None, flags = 0):
  157.         c = DBShelfCursor(self.db.cursor(txn, flags))
  158.         c.binary = self.binary
  159.         return c
  160.  
  161.     
  162.     def put(self, key, value, txn = None, flags = 0):
  163.         data = cPickle.dumps(value, self.binary)
  164.         return self.db.put(key, data, txn, flags)
  165.  
  166.     
  167.     def join(self, cursorList, flags = 0):
  168.         raise NotImplementedError
  169.  
  170.  
  171.  
  172. class DBShelfCursor:
  173.     '''
  174.     '''
  175.     
  176.     def __init__(self, cursor):
  177.         self.dbc = cursor
  178.  
  179.     
  180.     def __del__(self):
  181.         self.close()
  182.  
  183.     
  184.     def __getattr__(self, name):
  185.         '''Some methods we can just pass through to the cursor object.  (See below)'''
  186.         return getattr(self.dbc, name)
  187.  
  188.     
  189.     def dup(self, flags = 0):
  190.         return DBShelfCursor(self.dbc.dup(flags))
  191.  
  192.     
  193.     def put(self, key, value, flags = 0):
  194.         data = cPickle.dumps(value, self.binary)
  195.         return self.dbc.put(key, data, flags)
  196.  
  197.     
  198.     def get(self, *args):
  199.         count = len(args)
  200.         method = getattr(self, 'get_%d' % count)
  201.         apply(method, args)
  202.  
  203.     
  204.     def get_1(self, flags):
  205.         rec = self.dbc.get(flags)
  206.         return self._extract(rec)
  207.  
  208.     
  209.     def get_2(self, key, flags):
  210.         rec = self.dbc.get(key, flags)
  211.         return self._extract(rec)
  212.  
  213.     
  214.     def get_3(self, key, value, flags):
  215.         data = cPickle.dumps(value, self.binary)
  216.         rec = self.dbc.get(key, flags)
  217.         return self._extract(rec)
  218.  
  219.     
  220.     def current(self, flags = 0):
  221.         return self.get_1(flags | db.DB_CURRENT)
  222.  
  223.     
  224.     def first(self, flags = 0):
  225.         return self.get_1(flags | db.DB_FIRST)
  226.  
  227.     
  228.     def last(self, flags = 0):
  229.         return self.get_1(flags | db.DB_LAST)
  230.  
  231.     
  232.     def next(self, flags = 0):
  233.         return self.get_1(flags | db.DB_NEXT)
  234.  
  235.     
  236.     def prev(self, flags = 0):
  237.         return self.get_1(flags | db.DB_PREV)
  238.  
  239.     
  240.     def consume(self, flags = 0):
  241.         return self.get_1(flags | db.DB_CONSUME)
  242.  
  243.     
  244.     def next_dup(self, flags = 0):
  245.         return self.get_1(flags | db.DB_NEXT_DUP)
  246.  
  247.     
  248.     def next_nodup(self, flags = 0):
  249.         return self.get_1(flags | db.DB_NEXT_NODUP)
  250.  
  251.     
  252.     def prev_nodup(self, flags = 0):
  253.         return self.get_1(flags | db.DB_PREV_NODUP)
  254.  
  255.     
  256.     def get_both(self, key, value, flags = 0):
  257.         data = cPickle.dumps(value, self.binary)
  258.         rec = self.dbc.get_both(key, flags)
  259.         return self._extract(rec)
  260.  
  261.     
  262.     def set(self, key, flags = 0):
  263.         rec = self.dbc.set(key, flags)
  264.         return self._extract(rec)
  265.  
  266.     
  267.     def set_range(self, key, flags = 0):
  268.         rec = self.dbc.set_range(key, flags)
  269.         return self._extract(rec)
  270.  
  271.     
  272.     def set_recno(self, recno, flags = 0):
  273.         rec = self.dbc.set_recno(recno, flags)
  274.         return self._extract(rec)
  275.  
  276.     set_both = get_both
  277.     
  278.     def _extract(self, rec):
  279.         if rec is None:
  280.             return None
  281.         else:
  282.             (key, data) = rec
  283.             return (key, cPickle.loads(data))
  284.  
  285.  
  286.