Lib/UserDict.py

   1 """A more or less complete user-defined wrapper around dictionary objects."""
   2
   3 class UserDict:
   4     def __init__(self, dict=None, **kwargs):
   5         self.data = {}
   6         if dict is not None:
   7             self.update(dict)
   8         if len(kwargs):
   9             self.update(kwargs)
  10     def __repr__(self): return repr(self.data)
  11     def __cmp__(self, dict):
  12         if isinstance(dict, UserDict):
  13             return cmp(self.data, dict.data)
  14         else:
  15             return cmp(self.data, dict)
  16     def __len__(self): return len(self.data)
  17     def __getitem__(self, key):
  18         if key in self.data:
  19             return self.data[key]
  20         if hasattr(self.__class__, "__missing__"):
  21             return self.__class__.__missing__(self, key)
  22         raise KeyError(key)
  23     def __setitem__(self, key, item): self.data[key] = item
  24     def __delitem__(self, key): del self.data[key]
  25     def clear(self): self.data.clear()
  26     def copy(self):
  27         if self.__class__ is UserDict:
  28             return UserDict(self.data.copy())
  29         import copy
  30         data = self.data
  31         try:
  32             self.data = {}
  33             c = copy.copy(self)
  34         finally:
  35             self.data = data
  36         c.update(self)
  37         return c
  38     def keys(self): return self.data.keys()
  39     def items(self): return self.data.items()
  40     def iteritems(self): return self.data.iteritems()
  41     def iterkeys(self): return self.data.iterkeys()
  42     def itervalues(self): return self.data.itervalues()
  43     def values(self): return self.data.values()
  44     def has_key(self, key): return self.data.has_key(key)
  45     def update(self, dict=None, **kwargs):
  46         if dict is None:
  47             pass
  48         elif isinstance(dict, UserDict):
  49             self.data.update(dict.data)
  50         elif isinstance(dict, type({})) or not hasattr(dict, 'items'):
  51             self.data.update(dict)
  52         else:
  53             for k, v in dict.items():
  54                 self[k] = v
  55         if len(kwargs):
  56             self.data.update(kwargs)
  57     def get(self, key, failobj=None):
  58         if not self.has_key(key):
  59             return failobj
  60         return self[key]
  61     def setdefault(self, key, failobj=None):
  62         if not self.has_key(key):
  63             self[key] = failobj
  64         return self[key]
  65     def pop(self, key, *args):
  66         return self.data.pop(key, *args)
  67     def popitem(self):
  68         return self.data.popitem()
  69     def __contains__(self, key):
  70         return key in self.data
  71     @classmethod
  72     def fromkeys(cls, iterable, value=None):
  73         d = cls()
  74         for key in iterable:
  75             d[key] = value
  76         return d
  77
  78 class IterableUserDict(UserDict):
  79     def __iter__(self):
  80         return iter(self.data)
  81
  82 class DictMixin:
  83     # Mixin defining all dictionary methods for classes that already have
  84     # a minimum dictionary interface including getitem, setitem, delitem,
  85     # and keys. Without knowledge of the subclass constructor, the mixin
  86     # does not define __init__() or copy().  In addition to the four base
  87     # methods, progressively more efficiency comes with defining
  88     # __contains__(), __iter__(), and iteritems().
  89
  90     # second level definitions support higher levels
  91     def __iter__(self):
  92         for k in self.keys():
  93             yield k
  94     def has_key(self, key):
  95         try:
  96             value = self[key]
  97         except KeyError:
  98             return False
  99         return True
 100     def __contains__(self, key):
 101         return self.has_key(key)
 102
 103     # third level takes advantage of second level definitions
 104     def iteritems(self):
 105         for k in self:
 106             yield (k, self[k])
 107     def iterkeys(self):
 108         return self.__iter__()
 109
 110     # fourth level uses definitions from lower levels
 111     def itervalues(self):
 112         for _, v in self.iteritems():
 113             yield v
 114     def values(self):
 115         return [v for _, v in self.iteritems()]
 116     def items(self):
 117         return list(self.iteritems())
 118     def clear(self):
 119         for key in self.keys():
 120             del self[key]
 121     def setdefault(self, key, default=None):
 122         try:
 123             return self[key]
 124         except KeyError:
 125             self[key] = default
 126         return default
 127     def pop(self, key, *args):
 128         if len(args) > 1:
 129             raise TypeError, "pop expected at most 2 arguments, got "\
 130                               + repr(1 + len(args))
 131         try:
 132             value = self[key]
 133         except KeyError:
 134             if args:
 135                 return args[0]
 136             raise
 137         del self[key]
 138         return value
 139     def popitem(self):
 140         try:
 141             k, v = self.iteritems().next()
 142         except StopIteration:
 143             raise KeyError, 'container is empty'
 144         del self[k]
 145         return (k, v)
 146     def update(self, other=None, **kwargs):
 147         # Make progressively weaker assumptions about "other"
 148         if other is None:
 149             pass
 150         elif hasattr(other, 'iteritems'):  # iteritems saves memory and lookups
 151             for k, v in other.iteritems():
 152                 self[k] = v
 153         elif hasattr(other, 'keys'):
 154             for k in other.keys():
 155                 self[k] = other[k]
 156         else:
 157             for k, v in other:
 158                 self[k] = v
 159         if kwargs:
 160             self.update(kwargs)
 161     def get(self, key, default=None):
 162         try:
 163             return self[key]
 164         except KeyError:
 165             return default
 166     def __repr__(self):
 167         return repr(dict(self.iteritems()))
 168     def __cmp__(self, other):
 169         if other is None:
 170             return 1
 171         if isinstance(other, DictMixin):
 172             other = dict(other.iteritems())
 173         return cmp(dict(self.iteritems()), other)
 174     def __len__(self):
 175         return len(self.keys())