home *** CD-ROM | disk | FTP | other *** search
/ PC World 2007 September / PCWorld_2007-09_cd.bin / system / ntfs / ntfsundelete.exe / {app} / UserDict.pyc (.txt) < prev   
Encoding:
Python Compiled Bytecode  |  2007-02-05  |  7.6 KB  |  290 lines
  1. # Source Generated with Decompyle++
  2. # File: in.pyc (Python 2.4)
  3.  
  4. '''A more or less complete user-defined wrapper around dictionary objects.'''
  5.  
  6. class UserDict:
  7.     
  8.     def __init__(self, dict = None, **kwargs):
  9.         self.data = { }
  10.         if dict is not None:
  11.             self.update(dict)
  12.         
  13.         if len(kwargs):
  14.             self.update(kwargs)
  15.         
  16.  
  17.     
  18.     def __repr__(self):
  19.         return repr(self.data)
  20.  
  21.     
  22.     def __cmp__(self, dict):
  23.         if isinstance(dict, UserDict):
  24.             return cmp(self.data, dict.data)
  25.         else:
  26.             return cmp(self.data, dict)
  27.  
  28.     
  29.     def __len__(self):
  30.         return len(self.data)
  31.  
  32.     
  33.     def __getitem__(self, key):
  34.         return self.data[key]
  35.  
  36.     
  37.     def __setitem__(self, key, item):
  38.         self.data[key] = item
  39.  
  40.     
  41.     def __delitem__(self, key):
  42.         del self.data[key]
  43.  
  44.     
  45.     def clear(self):
  46.         self.data.clear()
  47.  
  48.     
  49.     def copy(self):
  50.         if self.__class__ is UserDict:
  51.             return UserDict(self.data.copy())
  52.         
  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 self.data.has_key(key)
  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.     
  110.     def get(self, key, failobj = None):
  111.         if not self.has_key(key):
  112.             return failobj
  113.         
  114.         return self[key]
  115.  
  116.     
  117.     def setdefault(self, key, failobj = None):
  118.         if not self.has_key(key):
  119.             self[key] = failobj
  120.         
  121.         return self[key]
  122.  
  123.     
  124.     def pop(self, key, *args):
  125.         return self.data.pop(key, *args)
  126.  
  127.     
  128.     def popitem(self):
  129.         return self.data.popitem()
  130.  
  131.     
  132.     def __contains__(self, key):
  133.         return key in self.data
  134.  
  135.     
  136.     def fromkeys(cls, iterable, value = None):
  137.         d = cls()
  138.         for key in iterable:
  139.             d[key] = value
  140.         
  141.         return d
  142.  
  143.     fromkeys = classmethod(fromkeys)
  144.  
  145.  
  146. class IterableUserDict(UserDict):
  147.     
  148.     def __iter__(self):
  149.         return iter(self.data)
  150.  
  151.  
  152.  
  153. class DictMixin:
  154.     
  155.     def __iter__(self):
  156.         for k in self.keys():
  157.             yield k
  158.         
  159.  
  160.     
  161.     def has_key(self, key):
  162.         
  163.         try:
  164.             value = self[key]
  165.         except KeyError:
  166.             return False
  167.  
  168.         return True
  169.  
  170.     
  171.     def __contains__(self, key):
  172.         return self.has_key(key)
  173.  
  174.     
  175.     def iteritems(self):
  176.         for k in self:
  177.             yield (k, self[k])
  178.         
  179.  
  180.     
  181.     def iterkeys(self):
  182.         return self.__iter__()
  183.  
  184.     
  185.     def itervalues(self):
  186.         for _, v in self.iteritems():
  187.             yield v
  188.         
  189.  
  190.     
  191.     def values(self):
  192.         return [ v for _, v in self.iteritems() ]
  193.  
  194.     
  195.     def items(self):
  196.         return list(self.iteritems())
  197.  
  198.     
  199.     def clear(self):
  200.         for key in self.keys():
  201.             del self[key]
  202.         
  203.  
  204.     
  205.     def setdefault(self, key, default = None):
  206.         
  207.         try:
  208.             return self[key]
  209.         except KeyError:
  210.             self[key] = default
  211.  
  212.         return default
  213.  
  214.     
  215.     def pop(self, key, *args):
  216.         if len(args) > 1:
  217.             raise TypeError, 'pop expected at most 2 arguments, got ' + repr(1 + len(args))
  218.         
  219.         
  220.         try:
  221.             value = self[key]
  222.         except KeyError:
  223.             if args:
  224.                 return args[0]
  225.             
  226.             raise 
  227.  
  228.         del self[key]
  229.         return value
  230.  
  231.     
  232.     def popitem(self):
  233.         
  234.         try:
  235.             (k, v) = self.iteritems().next()
  236.         except StopIteration:
  237.             raise KeyError, 'container is empty'
  238.  
  239.         del self[k]
  240.         return (k, v)
  241.  
  242.     
  243.     def update(self, other = None, **kwargs):
  244.         if other is None:
  245.             pass
  246.         elif hasattr(other, 'iteritems'):
  247.             for k, v in other.iteritems():
  248.                 self[k] = v
  249.             
  250.         elif hasattr(other, 'keys'):
  251.             for k in other.keys():
  252.                 self[k] = other[k]
  253.             
  254.         else:
  255.             for k, v in other:
  256.                 self[k] = v
  257.             
  258.         if kwargs:
  259.             self.update(kwargs)
  260.         
  261.  
  262.     
  263.     def get(self, key, default = None):
  264.         
  265.         try:
  266.             return self[key]
  267.         except KeyError:
  268.             return default
  269.  
  270.  
  271.     
  272.     def __repr__(self):
  273.         return repr(dict(self.iteritems()))
  274.  
  275.     
  276.     def __cmp__(self, other):
  277.         if other is None:
  278.             return 1
  279.         
  280.         if isinstance(other, DictMixin):
  281.             other = dict(other.iteritems())
  282.         
  283.         return cmp(dict(self.iteritems()), other)
  284.  
  285.     
  286.     def __len__(self):
  287.         return len(self.keys())
  288.  
  289.  
  290.