home *** CD-ROM | disk | FTP | other *** search
/ Maximum CD 2010 November / maximum-cd-2010-11.iso / DiscContents / calibre-0.7.13.msi / file_279 (.txt) < prev    next >
Encoding:
Python Compiled Bytecode  |  2010-08-06  |  11.2 KB  |  324 lines
  1. # Source Generated with Decompyle++
  2. # File: in.pyc (Python 2.6)
  3.  
  4. import cPickle
  5. import sys
  6. import sys
  7. absolute_import = sys.version_info[0] >= 3
  8. if absolute_import:
  9.     exec 'from . import db'
  10. else:
  11.     import db
  12. if sys.version_info[:3] >= (2, 3, 0):
  13.     HIGHEST_PROTOCOL = cPickle.HIGHEST_PROTOCOL
  14.     if sys.version_info[:3] < (2, 4, 0):
  15.         
  16.         def _dumps(object, protocol):
  17.             return cPickle.dumps(object, protocol)
  18.  
  19.     else:
  20.         
  21.         def _dumps(object, protocol):
  22.             return cPickle.dumps(object, protocol = protocol)
  23.  
  24. else:
  25.     HIGHEST_PROTOCOL = None
  26.     
  27.     def _dumps(object, protocol):
  28.         return cPickle.dumps(object, bin = protocol)
  29.  
  30. if sys.version_info[0:2] <= (2, 5):
  31.     
  32.     try:
  33.         from UserDict import DictMixin
  34.     except ImportError:
  35.         
  36.         class DictMixin:
  37.             pass
  38.  
  39.  
  40.     MutableMapping = DictMixin
  41. else:
  42.     import collections
  43.     MutableMapping = collections.MutableMapping
  44.  
  45. def open(filename, flags = db.DB_CREATE, mode = 432, filetype = db.DB_HASH, dbenv = None, dbname = None):
  46.     if type(flags) == type(''):
  47.         sflag = flags
  48.         if sflag == 'r':
  49.             flags = db.DB_RDONLY
  50.         elif sflag == 'rw':
  51.             flags = 0
  52.         elif sflag == 'w':
  53.             flags = db.DB_CREATE
  54.         elif sflag == 'c':
  55.             flags = db.DB_CREATE
  56.         elif sflag == 'n':
  57.             flags = db.DB_TRUNCATE | db.DB_CREATE
  58.         else:
  59.             raise db.DBError, "flags should be one of 'r', 'w', 'c' or 'n' or use the bsddb.db.DB_* flags"
  60.     sflag == 'r'
  61.     d = DBShelf(dbenv)
  62.     d.open(filename, dbname, filetype, flags, mode)
  63.     return d
  64.  
  65.  
  66. class DBShelveError(db.DBError):
  67.     pass
  68.  
  69.  
  70. class DBShelf(MutableMapping):
  71.     
  72.     def __init__(self, dbenv = None):
  73.         self.db = db.DB(dbenv)
  74.         self._closed = True
  75.         if HIGHEST_PROTOCOL:
  76.             self.protocol = HIGHEST_PROTOCOL
  77.         else:
  78.             self.protocol = 1
  79.  
  80.     
  81.     def __del__(self):
  82.         self.close()
  83.  
  84.     
  85.     def __getattr__(self, name):
  86.         return getattr(self.db, name)
  87.  
  88.     
  89.     def __len__(self):
  90.         return len(self.db)
  91.  
  92.     
  93.     def __getitem__(self, key):
  94.         data = self.db[key]
  95.         return cPickle.loads(data)
  96.  
  97.     
  98.     def __setitem__(self, key, value):
  99.         data = _dumps(value, self.protocol)
  100.         self.db[key] = data
  101.  
  102.     
  103.     def __delitem__(self, key):
  104.         del self.db[key]
  105.  
  106.     
  107.     def keys(self, txn = None):
  108.         if txn != None:
  109.             return self.db.keys(txn)
  110.         return self.db.keys()
  111.  
  112.     if sys.version_info[0:2] >= (2, 6):
  113.         
  114.         def __iter__(self):
  115.             return self.db.__iter__()
  116.  
  117.     
  118.     
  119.     def open(self, *args, **kwargs):
  120.         self.db.open(*args, **kwargs)
  121.         self._closed = False
  122.  
  123.     
  124.     def close(self, *args, **kwargs):
  125.         self.db.close(*args, **kwargs)
  126.         self._closed = True
  127.  
  128.     
  129.     def __repr__(self):
  130.         if self._closed:
  131.             return '<DBShelf @ 0x%x - closed>' % id(self)
  132.         return repr(dict(self.iteritems()))
  133.  
  134.     
  135.     def items(self, txn = None):
  136.         if txn != None:
  137.             items = self.db.items(txn)
  138.         else:
  139.             items = self.db.items()
  140.         newitems = []
  141.         for k, v in items:
  142.             newitems.append((k, cPickle.loads(v)))
  143.         
  144.         return newitems
  145.  
  146.     
  147.     def values(self, txn = None):
  148.         if txn != None:
  149.             values = self.db.values(txn)
  150.         else:
  151.             values = self.db.values()
  152.         return map(cPickle.loads, values)
  153.  
  154.     
  155.     def __append(self, value, txn = None):
  156.         data = _dumps(value, self.protocol)
  157.         return self.db.append(data, txn)
  158.  
  159.     
  160.     def append(self, value, txn = None):
  161.         if self.get_type() == db.DB_RECNO:
  162.             return self._DBShelf__append(value, txn = txn)
  163.         raise DBShelveError, 'append() only supported when dbshelve opened with filetype=dbshelve.db.DB_RECNO'
  164.  
  165.     
  166.     def associate(self, secondaryDB, callback, flags = 0):
  167.         
  168.         def _shelf_callback(priKey, priData, realCallback = callback):
  169.             if sys.version_info[0] < 3 or isinstance(priData, bytes):
  170.                 data = cPickle.loads(priData)
  171.             else:
  172.                 data = cPickle.loads(bytes(priData, 'iso8859-1'))
  173.             return realCallback(priKey, data)
  174.  
  175.         return self.db.associate(secondaryDB, _shelf_callback, flags)
  176.  
  177.     
  178.     def get(self, *args, **kw):
  179.         data = apply(self.db.get, args, kw)
  180.         
  181.         try:
  182.             return cPickle.loads(data)
  183.         except (EOFError, TypeError, cPickle.UnpicklingError):
  184.             return data
  185.  
  186.  
  187.     
  188.     def get_both(self, key, value, txn = None, flags = 0):
  189.         data = _dumps(value, self.protocol)
  190.         data = self.db.get(key, data, txn, flags)
  191.         return cPickle.loads(data)
  192.  
  193.     
  194.     def cursor(self, txn = None, flags = 0):
  195.         c = DBShelfCursor(self.db.cursor(txn, flags))
  196.         c.protocol = self.protocol
  197.         return c
  198.  
  199.     
  200.     def put(self, key, value, txn = None, flags = 0):
  201.         data = _dumps(value, self.protocol)
  202.         return self.db.put(key, data, txn, flags)
  203.  
  204.     
  205.     def join(self, cursorList, flags = 0):
  206.         raise NotImplementedError
  207.  
  208.  
  209.  
  210. class DBShelfCursor:
  211.     
  212.     def __init__(self, cursor):
  213.         self.dbc = cursor
  214.  
  215.     
  216.     def __del__(self):
  217.         self.close()
  218.  
  219.     
  220.     def __getattr__(self, name):
  221.         return getattr(self.dbc, name)
  222.  
  223.     
  224.     def dup(self, flags = 0):
  225.         c = DBShelfCursor(self.dbc.dup(flags))
  226.         c.protocol = self.protocol
  227.         return c
  228.  
  229.     
  230.     def put(self, key, value, flags = 0):
  231.         data = _dumps(value, self.protocol)
  232.         return self.dbc.put(key, data, flags)
  233.  
  234.     
  235.     def get(self, *args):
  236.         count = len(args)
  237.         method = getattr(self, 'get_%d' % count)
  238.         apply(method, args)
  239.  
  240.     
  241.     def get_1(self, flags):
  242.         rec = self.dbc.get(flags)
  243.         return self._extract(rec)
  244.  
  245.     
  246.     def get_2(self, key, flags):
  247.         rec = self.dbc.get(key, flags)
  248.         return self._extract(rec)
  249.  
  250.     
  251.     def get_3(self, key, value, flags):
  252.         data = _dumps(value, self.protocol)
  253.         rec = self.dbc.get(key, flags)
  254.         return self._extract(rec)
  255.  
  256.     
  257.     def current(self, flags = 0):
  258.         return self.get_1(flags | db.DB_CURRENT)
  259.  
  260.     
  261.     def first(self, flags = 0):
  262.         return self.get_1(flags | db.DB_FIRST)
  263.  
  264.     
  265.     def last(self, flags = 0):
  266.         return self.get_1(flags | db.DB_LAST)
  267.  
  268.     
  269.     def next(self, flags = 0):
  270.         return self.get_1(flags | db.DB_NEXT)
  271.  
  272.     
  273.     def prev(self, flags = 0):
  274.         return self.get_1(flags | db.DB_PREV)
  275.  
  276.     
  277.     def consume(self, flags = 0):
  278.         return self.get_1(flags | db.DB_CONSUME)
  279.  
  280.     
  281.     def next_dup(self, flags = 0):
  282.         return self.get_1(flags | db.DB_NEXT_DUP)
  283.  
  284.     
  285.     def next_nodup(self, flags = 0):
  286.         return self.get_1(flags | db.DB_NEXT_NODUP)
  287.  
  288.     
  289.     def prev_nodup(self, flags = 0):
  290.         return self.get_1(flags | db.DB_PREV_NODUP)
  291.  
  292.     
  293.     def get_both(self, key, value, flags = 0):
  294.         data = _dumps(value, self.protocol)
  295.         rec = self.dbc.get_both(key, flags)
  296.         return self._extract(rec)
  297.  
  298.     
  299.     def set(self, key, flags = 0):
  300.         rec = self.dbc.set(key, flags)
  301.         return self._extract(rec)
  302.  
  303.     
  304.     def set_range(self, key, flags = 0):
  305.         rec = self.dbc.set_range(key, flags)
  306.         return self._extract(rec)
  307.  
  308.     
  309.     def set_recno(self, recno, flags = 0):
  310.         rec = self.dbc.set_recno(recno, flags)
  311.         return self._extract(rec)
  312.  
  313.     set_both = get_both
  314.     
  315.     def _extract(self, rec):
  316.         if rec is None:
  317.             return None
  318.         (key, data) = rec
  319.         if sys.version_info[0] < 3 or isinstance(data, bytes):
  320.             return (key, cPickle.loads(data))
  321.         return (key, cPickle.loads(bytes(data, 'iso8859-1')))
  322.  
  323.  
  324.