|
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()) |