1
2
3
4 """Implements a case-insensitive (on keys) dictionary and order-sensitive dictionary"""
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
26 """this uses the object's upper method - works with string and unicode"""
27 if str is None:
28 return str
29 return str.upper()
30
31
33
35 """constructs the cidict, optionally using another dict to do so"""
36 if fromdict is not None:
37 self.update(fromdict)
38
40 if type(key) != str and type(key) != unicode:
41 raise TypeError("cidict can only have str or unicode as key (got %r)" % type(key))
42 for akey in self.iterkeys():
43 if akey.lower() == key.lower():
44 return dict.__getitem__(self, akey)
45 raise IndexError
46
54
56 """D.update(E) -> None. Update D from E: for k in E.keys(): D[k] = E[k]"""
57 for key, value in updatedict.iteritems():
58 self[key] = value
59
61 if type(key) != str and type(key) != unicode:
62 raise TypeError("cidict can only have str or unicode as key (got %r)" % type(key))
63 for akey in self.iterkeys():
64 if akey.lower() == key.lower():
65 return dict.__delitem__(self, akey)
66 raise IndexError
67
69 if type(key) != str and type(key) != unicode:
70 raise TypeError("cidict can only have str or unicode as key (got %r)" % type(key))
71 for akey in self.iterkeys():
72 if akey.lower() == key.lower():
73 return 1
74 return 0
75
78
79 - def get(self, key, default=None):
80 if self.has_key(key):
81 return self[key]
82 else:
83 return default
84
85
87 """a dictionary which remembers its keys in the order in which they were given"""
88
90 if len(args) == 0:
91 super(ordereddict, self).__init__()
92 self.order = []
93 elif len(args) > 1:
94 raise TypeError("ordereddict() takes at most 1 argument (%d given)" % len(args))
95 else:
96 initarg = args[0]
97 apply(super(ordereddict, self).__init__, args)
98 if hasattr(initarg, "keys"):
99 self.order = initarg.keys()
100 else:
101
102 self.order = []
103 checkduplicates = {}
104 for key, value in initarg:
105 if not key in checkduplicates:
106 self.order.append(key)
107 checkduplicates[key] = None
108
110 alreadypresent = key in self
111 result = dict.__setitem__(self, key, value)
112 if not alreadypresent:
113 self.order.append(key)
114 return result
115
116 - def update(self, updatedict):
117 """D.update(E) -> None. Update D from E: for k in E.keys(): D[k] = E[k]"""
118 for key, value in updatedict.iteritems():
119 self[key] = value
120
122 alreadypresent = key in self
123 result = dict.__delitem__(self, key)
124 if alreadypresent:
125 del self.order[self.order.index(key)]
126 return result
127
129 """D.copy() -> a shallow copy of D"""
130 thecopy = ordereddict(super(ordereddict, self).copy())
131 thecopy.order = self.order[:]
132 return thecopy
133
135 """D.items() -> list of D's (key, value) pairs, as 2-tuples"""
136 return [(key, self[key]) for key in self.order]
137
139 """D.iteritems() -> an iterator over the (key, value) items of D"""
140 for key in self.order:
141 yield (key, self[key])
142
144 """D.iterkeys() -> an iterator over the keys of D"""
145 for key in self.order:
146 yield key
147
148 __iter__ = iterkeys
149
151 """D.itervalues() -> an iterator over the values of D"""
152 for key in self.order:
153 yield self[key]
154
156 """D.keys() -> list of D's keys"""
157 return self.order[:]
158
160 """D.popitem() -> (k, v), remove and return some (key, value) pair as a 2-tuple; but raise KeyError if D is empty"""
161 if len(self.order) == 0:
162 raise KeyError("popitem(): ordered dictionary is empty")
163 k = self.order.pop()
164 v = self[k]
165 del self[k]
166 return (k, v)
167
168 - def pop(self, key):
169 """remove entry from dict and internal list"""
170 value = super(ordereddict, self).pop(key)
171 del self.order[self.order.index(key)]
172 return value
173