1# Backport of OrderedDict() class that runs on Python 2.4, 2.5, 2.6, 2.7 and pypy.
2# Passes Python2.7's test suite and incorporates all the latest updates.
3# Copyright 2009 Raymond Hettinger, released under the MIT License.
4# http://code.activestate.com/recipes/576693/
5try:
6    from thread import get_ident as _get_ident
7except ImportError:
8    from dummy_thread import get_ident as _get_ident
9
10try:
11    from _abcoll import KeysView, ValuesView, ItemsView
12except ImportError:
13    pass
14
15
16class OrderedDict(dict):
17    'Dictionary that remembers insertion order'
18    # An inherited dict maps keys to values.
19    # The inherited dict provides __getitem__, __len__, __contains__, and get.
20    # The remaining methods are order-aware.
21    # Big-O running times for all methods are the same as for regular dictionaries.
22
23    # The internal self.__map dictionary maps keys to links in a doubly linked list.
24    # The circular doubly linked list starts and ends with a sentinel element.
25    # The sentinel element never gets deleted (this simplifies the algorithm).
26    # Each link is stored as a list of length three:  [PREV, NEXT, KEY].
27
28    def __init__(self, *args, **kwds):
29        '''Initialize an ordered dictionary.  Signature is the same as for
30        regular dictionaries, but keyword arguments are not recommended
31        because their insertion order is arbitrary.
32
33        '''
34        if len(args) > 1:
35            raise TypeError('expected at most 1 arguments, got %d' % len(args))
36        try:
37            self.__root
38        except AttributeError:
39            self.__root = root = []                     # sentinel node
40            root[:] = [root, root, None]
41            self.__map = {}
42        self.__update(*args, **kwds)
43
44    def __setitem__(self, key, value, dict_setitem=dict.__setitem__):
45        'od.__setitem__(i, y) <==> od[i]=y'
46        # Setting a new item creates a new link which goes at the end of the linked
47        # list, and the inherited dictionary is updated with the new key/value pair.
48        if key not in self:
49            root = self.__root
50            last = root[0]
51            last[1] = root[0] = self.__map[key] = [last, root, key]
52        dict_setitem(self, key, value)
53
54    def __delitem__(self, key, dict_delitem=dict.__delitem__):
55        'od.__delitem__(y) <==> del od[y]'
56        # Deleting an existing item uses self.__map to find the link which is
57        # then removed by updating the links in the predecessor and successor nodes.
58        dict_delitem(self, key)
59        link_prev, link_next, key = self.__map.pop(key)
60        link_prev[1] = link_next
61        link_next[0] = link_prev
62
63    def __iter__(self):
64        'od.__iter__() <==> iter(od)'
65        root = self.__root
66        curr = root[1]
67        while curr is not root:
68            yield curr[2]
69            curr = curr[1]
70
71    def __reversed__(self):
72        'od.__reversed__() <==> reversed(od)'
73        root = self.__root
74        curr = root[0]
75        while curr is not root:
76            yield curr[2]
77            curr = curr[0]
78
79    def clear(self):
80        'od.clear() -> None.  Remove all items from od.'
81        try:
82            for node in self.__map.itervalues():
83                del node[:]
84            root = self.__root
85            root[:] = [root, root, None]
86            self.__map.clear()
87        except AttributeError:
88            pass
89        dict.clear(self)
90
91    def popitem(self, last=True):
92        '''od.popitem() -> (k, v), return and remove a (key, value) pair.
93        Pairs are returned in LIFO order if last is true or FIFO order if false.
94
95        '''
96        if not self:
97            raise KeyError('dictionary is empty')
98        root = self.__root
99        if last:
100            link = root[0]
101            link_prev = link[0]
102            link_prev[1] = root
103            root[0] = link_prev
104        else:
105            link = root[1]
106            link_next = link[1]
107            root[1] = link_next
108            link_next[0] = root
109        key = link[2]
110        del self.__map[key]
111        value = dict.pop(self, key)
112        return key, value
113
114    # -- the following methods do not depend on the internal structure --
115
116    def keys(self):
117        'od.keys() -> list of keys in od'
118        return list(self)
119
120    def values(self):
121        'od.values() -> list of values in od'
122        return [self[key] for key in self]
123
124    def items(self):
125        'od.items() -> list of (key, value) pairs in od'
126        return [(key, self[key]) for key in self]
127
128    def iterkeys(self):
129        'od.iterkeys() -> an iterator over the keys in od'
130        return iter(self)
131
132    def itervalues(self):
133        'od.itervalues -> an iterator over the values in od'
134        for k in self:
135            yield self[k]
136
137    def iteritems(self):
138        'od.iteritems -> an iterator over the (key, value) items in od'
139        for k in self:
140            yield (k, self[k])
141
142    def update(*args, **kwds):
143        '''od.update(E, **F) -> None.  Update od from dict/iterable E and F.
144
145        If E is a dict instance, does:           for k in E: od[k] = E[k]
146        If E has a .keys() method, does:         for k in E.keys(): od[k] = E[k]
147        Or if E is an iterable of items, does:   for k, v in E: od[k] = v
148        In either case, this is followed by:     for k, v in F.items(): od[k] = v
149
150        '''
151        if len(args) > 2:
152            raise TypeError('update() takes at most 2 positional '
153                            'arguments (%d given)' % (len(args),))
154        elif not args:
155            raise TypeError('update() takes at least 1 argument (0 given)')
156        self = args[0]
157        # Make progressively weaker assumptions about "other"
158        other = ()
159        if len(args) == 2:
160            other = args[1]
161        if isinstance(other, dict):
162            for key in other:
163                self[key] = other[key]
164        elif hasattr(other, 'keys'):
165            for key in other.keys():
166                self[key] = other[key]
167        else:
168            for key, value in other:
169                self[key] = value
170        for key, value in kwds.items():
171            self[key] = value
172
173    __update = update  # let subclasses override update without breaking __init__
174
175    __marker = object()
176
177    def pop(self, key, default=__marker):
178        '''od.pop(k[,d]) -> v, remove specified key and return the corresponding value.
179        If key is not found, d is returned if given, otherwise KeyError is raised.
180
181        '''
182        if key in self:
183            result = self[key]
184            del self[key]
185            return result
186        if default is self.__marker:
187            raise KeyError(key)
188        return default
189
190    def setdefault(self, key, default=None):
191        'od.setdefault(k[,d]) -> od.get(k,d), also set od[k]=d if k not in od'
192        if key in self:
193            return self[key]
194        self[key] = default
195        return default
196
197    def __repr__(self, _repr_running={}):
198        'od.__repr__() <==> repr(od)'
199        call_key = id(self), _get_ident()
200        if call_key in _repr_running:
201            return '...'
202        _repr_running[call_key] = 1
203        try:
204            if not self:
205                return '%s()' % (self.__class__.__name__,)
206            return '%s(%r)' % (self.__class__.__name__, self.items())
207        finally:
208            del _repr_running[call_key]
209
210    def __reduce__(self):
211        'Return state information for pickling'
212        items = [[k, self[k]] for k in self]
213        inst_dict = vars(self).copy()
214        for k in vars(OrderedDict()):
215            inst_dict.pop(k, None)
216        if inst_dict:
217            return (self.__class__, (items,), inst_dict)
218        return self.__class__, (items,)
219
220    def copy(self):
221        'od.copy() -> a shallow copy of od'
222        return self.__class__(self)
223
224    @classmethod
225    def fromkeys(cls, iterable, value=None):
226        '''OD.fromkeys(S[, v]) -> New ordered dictionary with keys from S
227        and values equal to v (which defaults to None).
228
229        '''
230        d = cls()
231        for key in iterable:
232            d[key] = value
233        return d
234
235    def __eq__(self, other):
236        '''od.__eq__(y) <==> od==y.  Comparison to another OD is order-sensitive
237        while comparison to a regular mapping is order-insensitive.
238
239        '''
240        if isinstance(other, OrderedDict):
241            return len(self)==len(other) and self.items() == other.items()
242        return dict.__eq__(self, other)
243
244    def __ne__(self, other):
245        return not self == other
246
247    # -- the following methods are only used in Python 2.7 --
248
249    def viewkeys(self):
250        "od.viewkeys() -> a set-like object providing a view on od's keys"
251        return KeysView(self)
252
253    def viewvalues(self):
254        "od.viewvalues() -> an object providing a view on od's values"
255        return ValuesView(self)
256
257    def viewitems(self):
258        "od.viewitems() -> a set-like object providing a view on od's items"
259        return ItemsView(self)
260