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