Hot-keys on this page

r m x p   toggle line displays

j k   next/prev highlighted chunk

0   (zero) top of page

1   (one) first highlighted chunk

1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

19

20

21

22

23

24

25

26

27

28

29

30

31

32

33

34

35

36

37

38

39

40

41

42

43

44

45

46

47

48

49

50

51

52

53

54

55

56

57

58

59

60

61

62

63

64

65

66

67

68

69

70

71

72

73

74

75

76

77

78

79

80

81

82

83

84

85

86

87

88

89

90

91

92

93

94

95

96

97

98

99

100

101

102

103

104

105

106

107

108

109

110

111

112

113

114

115

116

117

118

119

120

121

122

123

124

125

126

127

128

129

130

131

132

133

134

135

136

137

138

139

140

141

142

143

144

145

146

147

148

149

150

151

152

153

154

155

156

157

158

159

160

161

162

163

164

165

166

167

168

169

170

171

172

173

174

175

176

177

178

179

180

181

182

183

184

185

186

187

188

189

190

191

192

193

194

195

196

197

198

199

200

201

202

203

204

205

206

207

208

209

210

211

212

213

214

215

216

217

218

219

220

221

222

223

224

225

226

227

228

229

230

231

232

233

234

235

236

237

238

239

240

241

242

243

244

245

246

247

248

249

250

251

252

253

254

255

256

257

258

259

# Backport of OrderedDict() class that runs on Python 2.4, 2.5, 2.6, 2.7 and pypy. 

# Passes Python2.7's test suite and incorporates all the latest updates. 

# Copyright 2009 Raymond Hettinger, released under the MIT License. 

# http://code.activestate.com/recipes/576693/ 

try: 

    from thread import get_ident as _get_ident 

except ImportError: 

    from dummy_thread import get_ident as _get_ident 

 

try: 

    from _abcoll import KeysView, ValuesView, ItemsView 

except ImportError: 

    pass 

 

 

class OrderedDict(dict): 

    'Dictionary that remembers insertion order' 

    # An inherited dict maps keys to values. 

    # The inherited dict provides __getitem__, __len__, __contains__, and get. 

    # The remaining methods are order-aware. 

    # Big-O running times for all methods are the same as for regular dictionaries. 

 

    # The internal self.__map dictionary maps keys to links in a doubly linked list. 

    # The circular doubly linked list starts and ends with a sentinel element. 

    # The sentinel element never gets deleted (this simplifies the algorithm). 

    # Each link is stored as a list of length three:  [PREV, NEXT, KEY]. 

 

    def __init__(self, *args, **kwds): 

        '''Initialize an ordered dictionary.  Signature is the same as for 

        regular dictionaries, but keyword arguments are not recommended 

        because their insertion order is arbitrary. 

 

        ''' 

        if len(args) > 1: 

            raise TypeError('expected at most 1 arguments, got %d' % len(args)) 

        try: 

            self.__root 

        except AttributeError: 

            self.__root = root = []                     # sentinel node 

            root[:] = [root, root, None] 

            self.__map = {} 

        self.__update(*args, **kwds) 

 

    def __setitem__(self, key, value, dict_setitem=dict.__setitem__): 

        'od.__setitem__(i, y) <==> od[i]=y' 

        # Setting a new item creates a new link which goes at the end of the linked 

        # list, and the inherited dictionary is updated with the new key/value pair. 

        if key not in self: 

            root = self.__root 

            last = root[0] 

            last[1] = root[0] = self.__map[key] = [last, root, key] 

        dict_setitem(self, key, value) 

 

    def __delitem__(self, key, dict_delitem=dict.__delitem__): 

        'od.__delitem__(y) <==> del od[y]' 

        # Deleting an existing item uses self.__map to find the link which is 

        # then removed by updating the links in the predecessor and successor nodes. 

        dict_delitem(self, key) 

        link_prev, link_next, key = self.__map.pop(key) 

        link_prev[1] = link_next 

        link_next[0] = link_prev 

 

    def __iter__(self): 

        'od.__iter__() <==> iter(od)' 

        root = self.__root 

        curr = root[1] 

        while curr is not root: 

            yield curr[2] 

            curr = curr[1] 

 

    def __reversed__(self): 

        'od.__reversed__() <==> reversed(od)' 

        root = self.__root 

        curr = root[0] 

        while curr is not root: 

            yield curr[2] 

            curr = curr[0] 

 

    def clear(self): 

        'od.clear() -> None.  Remove all items from od.' 

        try: 

            for node in self.__map.itervalues(): 

                del node[:] 

            root = self.__root 

            root[:] = [root, root, None] 

            self.__map.clear() 

        except AttributeError: 

            pass 

        dict.clear(self) 

 

    def popitem(self, last=True): 

        '''od.popitem() -> (k, v), return and remove a (key, value) pair. 

        Pairs are returned in LIFO order if last is true or FIFO order if false. 

 

        ''' 

        if not self: 

            raise KeyError('dictionary is empty') 

        root = self.__root 

        if last: 

            link = root[0] 

            link_prev = link[0] 

            link_prev[1] = root 

            root[0] = link_prev 

        else: 

            link = root[1] 

            link_next = link[1] 

            root[1] = link_next 

            link_next[0] = root 

        key = link[2] 

        del self.__map[key] 

        value = dict.pop(self, key) 

        return key, value 

 

    # -- the following methods do not depend on the internal structure -- 

 

    def keys(self): 

        'od.keys() -> list of keys in od' 

        return list(self) 

 

    def values(self): 

        'od.values() -> list of values in od' 

        return [self[key] for key in self] 

 

    def items(self): 

        'od.items() -> list of (key, value) pairs in od' 

        return [(key, self[key]) for key in self] 

 

    def iterkeys(self): 

        'od.iterkeys() -> an iterator over the keys in od' 

        return iter(self) 

 

    def itervalues(self): 

        'od.itervalues -> an iterator over the values in od' 

        for k in self: 

            yield self[k] 

 

    def iteritems(self): 

        'od.iteritems -> an iterator over the (key, value) items in od' 

        for k in self: 

            yield (k, self[k]) 

 

    def update(*args, **kwds): 

        '''od.update(E, **F) -> None.  Update od from dict/iterable E and F. 

 

        If E is a dict instance, does:           for k in E: od[k] = E[k] 

        If E has a .keys() method, does:         for k in E.keys(): od[k] = E[k] 

        Or if E is an iterable of items, does:   for k, v in E: od[k] = v 

        In either case, this is followed by:     for k, v in F.items(): od[k] = v 

 

        ''' 

        if len(args) > 2: 

            raise TypeError('update() takes at most 2 positional ' 

                            'arguments (%d given)' % (len(args),)) 

        elif not args: 

            raise TypeError('update() takes at least 1 argument (0 given)') 

        self = args[0] 

        # Make progressively weaker assumptions about "other" 

        other = () 

        if len(args) == 2: 

            other = args[1] 

        if isinstance(other, dict): 

            for key in other: 

                self[key] = other[key] 

        elif hasattr(other, 'keys'): 

            for key in other.keys(): 

                self[key] = other[key] 

        else: 

            for key, value in other: 

                self[key] = value 

        for key, value in kwds.items(): 

            self[key] = value 

 

    __update = update  # let subclasses override update without breaking __init__ 

 

    __marker = object() 

 

    def pop(self, key, default=__marker): 

        '''od.pop(k[,d]) -> v, remove specified key and return the corresponding value. 

        If key is not found, d is returned if given, otherwise KeyError is raised. 

 

        ''' 

        if key in self: 

            result = self[key] 

            del self[key] 

            return result 

        if default is self.__marker: 

            raise KeyError(key) 

        return default 

 

    def setdefault(self, key, default=None): 

        'od.setdefault(k[,d]) -> od.get(k,d), also set od[k]=d if k not in od' 

        if key in self: 

            return self[key] 

        self[key] = default 

        return default 

 

    def __repr__(self, _repr_running={}): 

        'od.__repr__() <==> repr(od)' 

        call_key = id(self), _get_ident() 

        if call_key in _repr_running: 

            return '...' 

        _repr_running[call_key] = 1 

        try: 

            if not self: 

                return '%s()' % (self.__class__.__name__,) 

            return '%s(%r)' % (self.__class__.__name__, self.items()) 

        finally: 

            del _repr_running[call_key] 

 

    def __reduce__(self): 

        'Return state information for pickling' 

        items = [[k, self[k]] for k in self] 

        inst_dict = vars(self).copy() 

        for k in vars(OrderedDict()): 

            inst_dict.pop(k, None) 

        if inst_dict: 

            return (self.__class__, (items,), inst_dict) 

        return self.__class__, (items,) 

 

    def copy(self): 

        'od.copy() -> a shallow copy of od' 

        return self.__class__(self) 

 

    @classmethod 

    def fromkeys(cls, iterable, value=None): 

        '''OD.fromkeys(S[, v]) -> New ordered dictionary with keys from S 

        and values equal to v (which defaults to None). 

 

        ''' 

        d = cls() 

        for key in iterable: 

            d[key] = value 

        return d 

 

    def __eq__(self, other): 

        '''od.__eq__(y) <==> od==y.  Comparison to another OD is order-sensitive 

        while comparison to a regular mapping is order-insensitive. 

 

        ''' 

        if isinstance(other, OrderedDict): 

            return len(self)==len(other) and self.items() == other.items() 

        return dict.__eq__(self, other) 

 

    def __ne__(self, other): 

        return not self == other 

 

    # -- the following methods are only used in Python 2.7 -- 

 

    def viewkeys(self): 

        "od.viewkeys() -> a set-like object providing a view on od's keys" 

        return KeysView(self) 

 

    def viewvalues(self): 

        "od.viewvalues() -> an object providing a view on od's values" 

        return ValuesView(self) 

 

    def viewitems(self): 

        "od.viewitems() -> a set-like object providing a view on od's items" 

        return ItemsView(self)