home *** CD-ROM | disk | FTP | other *** search
/ Chip 2011 November / CHIP_2011_11.iso / Programy / Narzedzia / Calibre / calibre-0.8.18.msi / file_262 / UserDict.pyo (.txt) < prev    next >
Encoding:
Python Compiled Bytecode  |  2011-09-09  |  7.6 KB  |  283 lines
  1. # Source Generated with Decompyle++
  2. # File: in.pyo (Python 2.7)
  3.  
  4.  
  5. class UserDict:
  6.     
  7.     def __init__(self, dict = None, **kwargs):
  8.         self.data = { }
  9.         if dict is not None:
  10.             self.update(dict)
  11.         if len(kwargs):
  12.             self.update(kwargs)
  13.  
  14.     
  15.     def __repr__(self):
  16.         return repr(self.data)
  17.  
  18.     
  19.     def __cmp__(self, dict):
  20.         if isinstance(dict, UserDict):
  21.             return cmp(self.data, dict.data)
  22.         return None(self.data, dict)
  23.  
  24.     __hash__ = None
  25.     
  26.     def __len__(self):
  27.         return len(self.data)
  28.  
  29.     
  30.     def __getitem__(self, key):
  31.         if key in self.data:
  32.             return self.data[key]
  33.         if None(self.__class__, '__missing__'):
  34.             return self.__class__.__missing__(self, key)
  35.         raise None(key)
  36.  
  37.     
  38.     def __setitem__(self, key, item):
  39.         self.data[key] = item
  40.  
  41.     
  42.     def __delitem__(self, key):
  43.         del self.data[key]
  44.  
  45.     
  46.     def clear(self):
  47.         self.data.clear()
  48.  
  49.     
  50.     def copy(self):
  51.         if self.__class__ is UserDict:
  52.             return UserDict(self.data.copy())
  53.         import copy
  54.         data = self.data
  55.         
  56.         try:
  57.             self.data = { }
  58.             c = copy.copy(self)
  59.         finally:
  60.             self.data = data
  61.  
  62.         c.update(self)
  63.         return c
  64.  
  65.     
  66.     def keys(self):
  67.         return self.data.keys()
  68.  
  69.     
  70.     def items(self):
  71.         return self.data.items()
  72.  
  73.     
  74.     def iteritems(self):
  75.         return self.data.iteritems()
  76.  
  77.     
  78.     def iterkeys(self):
  79.         return self.data.iterkeys()
  80.  
  81.     
  82.     def itervalues(self):
  83.         return self.data.itervalues()
  84.  
  85.     
  86.     def values(self):
  87.         return self.data.values()
  88.  
  89.     
  90.     def has_key(self, key):
  91.         return key in self.data
  92.  
  93.     
  94.     def update(self, dict = None, **kwargs):
  95.         if dict is None:
  96.             pass
  97.         elif isinstance(dict, UserDict):
  98.             self.data.update(dict.data)
  99.         elif isinstance(dict, type({ })) or not hasattr(dict, 'items'):
  100.             self.data.update(dict)
  101.         else:
  102.             for k, v in dict.items():
  103.                 self[k] = v
  104.             
  105.         if len(kwargs):
  106.             self.data.update(kwargs)
  107.  
  108.     
  109.     def get(self, key, failobj = None):
  110.         if key not in self:
  111.             return failobj
  112.         return None[key]
  113.  
  114.     
  115.     def setdefault(self, key, failobj = None):
  116.         if key not in self:
  117.             self[key] = failobj
  118.         return self[key]
  119.  
  120.     
  121.     def pop(self, key, *args):
  122.         return self.data.pop(key, *args)
  123.  
  124.     
  125.     def popitem(self):
  126.         return self.data.popitem()
  127.  
  128.     
  129.     def __contains__(self, key):
  130.         return key in self.data
  131.  
  132.     
  133.     def fromkeys(cls, iterable, value = None):
  134.         d = cls()
  135.         for key in iterable:
  136.             d[key] = value
  137.         
  138.         return d
  139.  
  140.     fromkeys = classmethod(fromkeys)
  141.  
  142.  
  143. class IterableUserDict(UserDict):
  144.     
  145.     def __iter__(self):
  146.         return iter(self.data)
  147.  
  148.  
  149. import _abcoll
  150. _abcoll.MutableMapping.register(IterableUserDict)
  151.  
  152. class DictMixin:
  153.     
  154.     def __iter__(self):
  155.         for k in self.keys():
  156.             yield k
  157.         
  158.  
  159.     
  160.     def has_key(self, key):
  161.         
  162.         try:
  163.             self[key]
  164.         except KeyError:
  165.             return False
  166.  
  167.         return True
  168.  
  169.     
  170.     def __contains__(self, key):
  171.         return self.has_key(key)
  172.  
  173.     
  174.     def iteritems(self):
  175.         for k in self:
  176.             yield (k, self[k])
  177.         
  178.  
  179.     
  180.     def iterkeys(self):
  181.         return self.__iter__()
  182.  
  183.     
  184.     def itervalues(self):
  185.         for _, v in self.iteritems():
  186.             yield v
  187.         
  188.  
  189.     
  190.     def values(self):
  191.         return [ v for _, v in self.iteritems() ]
  192.  
  193.     
  194.     def items(self):
  195.         return list(self.iteritems())
  196.  
  197.     
  198.     def clear(self):
  199.         for key in self.keys():
  200.             del self[key]
  201.         
  202.  
  203.     
  204.     def setdefault(self, key, default = None):
  205.         
  206.         try:
  207.             return self[key]
  208.         except KeyError:
  209.             self[key] = default
  210.  
  211.         return default
  212.  
  213.     
  214.     def pop(self, key, *args):
  215.         if len(args) > 1:
  216.             raise TypeError, 'pop expected at most 2 arguments, got ' + repr(1 + len(args))
  217.         
  218.         try:
  219.             value = self[key]
  220.         except KeyError:
  221.             if args:
  222.                 return args[0]
  223.  
  224.         del self[key]
  225.         return value
  226.  
  227.     
  228.     def popitem(self):
  229.         
  230.         try:
  231.             (k, v) = self.iteritems().next()
  232.         except StopIteration:
  233.             raise KeyError, 'container is empty'
  234.  
  235.         del self[k]
  236.         return (k, v)
  237.  
  238.     
  239.     def update(self, other = None, **kwargs):
  240.         if other is None:
  241.             pass
  242.         elif hasattr(other, 'iteritems'):
  243.             for k, v in other.iteritems():
  244.                 self[k] = v
  245.             
  246.         elif hasattr(other, 'keys'):
  247.             for k in other.keys():
  248.                 self[k] = other[k]
  249.             
  250.         else:
  251.             for k, v in other:
  252.                 self[k] = v
  253.             
  254.         if kwargs:
  255.             self.update(kwargs)
  256.  
  257.     
  258.     def get(self, key, default = None):
  259.         
  260.         try:
  261.             return self[key]
  262.         except KeyError:
  263.             return default
  264.  
  265.  
  266.     
  267.     def __repr__(self):
  268.         return repr(dict(self.iteritems()))
  269.  
  270.     
  271.     def __cmp__(self, other):
  272.         if other is None:
  273.             return 1
  274.         if None(other, DictMixin):
  275.             other = dict(other.iteritems())
  276.         return cmp(dict(self.iteritems()), other)
  277.  
  278.     
  279.     def __len__(self):
  280.         return len(self.keys())
  281.  
  282.  
  283.