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