source: sasview/src/sas/sascalc/data_util/odict.py @ f00072f

ESS_GUIESS_GUI_DocsESS_GUI_batch_fittingESS_GUI_bumps_abstractionESS_GUI_iss1116ESS_GUI_iss879ESS_GUI_iss959ESS_GUI_openclESS_GUI_orderingESS_GUI_sync_sascalcmagnetic_scattrelease-4.2.2ticket-1009ticket-1094-headlessticket-1242-2d-resolutionticket-1243ticket-1249ticket885unittest-saveload
Last change on this file since f00072f was 574adc7, checked in by Paul Kienzle <pkienzle@…>, 7 years ago

convert sascalc to python 2/3 syntax
  • Property mode set to 100644
File size: 45.1 KB
RevLine 
[4bae1ef]1# odict.py
2# An Ordered Dictionary object
3# Copyright (C) 2005 Nicola Larosa, Michael Foord
4# E-mail: nico AT tekNico DOT net, fuzzyman AT voidspace DOT org DOT uk
5
6# This software is licensed under the terms of the BSD license.
7# http://www.voidspace.org.uk/python/license.shtml
8# Basically you're free to copy, modify, distribute and relicense it,
9# So long as you keep a copy of the license with it.
10
11# Documentation at http://www.voidspace.org.uk/python/odict.html
12# For information about bugfixes, updates and support, please join the
13# Pythonutils mailing list:
14# http://groups.google.com/group/pythonutils/
15# Comments, suggestions and bug reports welcome.
16
17"""A dict that keeps keys in insertion order"""
18from __future__ import generators
19
20__author__ = ('Nicola Larosa <nico-NoSp@m-tekNico.net>,'
21    'Michael Foord <fuzzyman AT voidspace DOT org DOT uk>')
22
23__docformat__ = "restructuredtext en"
24
25__revision__ = '$Id: odict.py 58 2008-09-02 14:09:54Z farrowch $'
26
27__version__ = '0.2.2'
28
29__all__ = ['OrderedDict', 'SequenceOrderedDict']
30
31import sys
32INTP_VER = sys.version_info[:2]
33if INTP_VER < (2, 2):
34    raise RuntimeError("Python v.2.2 or later required")
35
36import types, warnings
37
38class OrderedDict(dict):
39    """
40    A class of dictionary that keeps the insertion order of keys.
[574adc7]41
[4bae1ef]42    All appropriate methods return keys, items, or values in an ordered way.
[574adc7]43
[4bae1ef]44    All normal dictionary methods are available. Update and comparison is
45    restricted to other OrderedDict objects.
[574adc7]46
[4bae1ef]47    Various sequence methods are available, including the ability to explicitly
48    mutate the key ordering.
[574adc7]49
[4bae1ef]50    __contains__ tests:
[574adc7]51
[4bae1ef]52    >>> d = OrderedDict(((1, 3),))
53    >>> 1 in d
54    1
55    >>> 4 in d
56    0
[574adc7]57
[4bae1ef]58    __getitem__ tests:
[574adc7]59
[4bae1ef]60    >>> OrderedDict(((1, 3), (3, 2), (2, 1)))[2]
61    1
62    >>> OrderedDict(((1, 3), (3, 2), (2, 1)))[4]
63    Traceback (most recent call last):
64    KeyError: 4
[574adc7]65
[4bae1ef]66    __len__ tests:
[574adc7]67
[4bae1ef]68    >>> len(OrderedDict())
69    0
70    >>> len(OrderedDict(((1, 3), (3, 2), (2, 1))))
71    3
[574adc7]72
[4bae1ef]73    get tests:
[574adc7]74
[4bae1ef]75    >>> d = OrderedDict(((1, 3), (3, 2), (2, 1)))
76    >>> d.get(1)
77    3
78    >>> d.get(4) is None
79    1
80    >>> d.get(4, 5)
81    5
82    >>> d
83    OrderedDict([(1, 3), (3, 2), (2, 1)])
[574adc7]84
[4bae1ef]85    has_key tests:
[574adc7]86
[4bae1ef]87    >>> d = OrderedDict(((1, 3), (3, 2), (2, 1)))
88    >>> d.has_key(1)
89    1
90    >>> d.has_key(4)
91    0
92    """
93
94    def __init__(self, init_val=(), strict=False):
95        """
96        Create a new ordered dictionary. Cannot init from a normal dict,
97        nor from kwargs, since items order is undefined in those cases.
[574adc7]98
[4bae1ef]99        If the ``strict`` keyword argument is ``True`` (``False`` is the
100        default) then when doing slice assignment - the ``OrderedDict`` you are
101        assigning from *must not* contain any keys in the remaining dict.
[574adc7]102
[4bae1ef]103        >>> OrderedDict()
104        OrderedDict([])
105        >>> OrderedDict({1: 1})
106        Traceback (most recent call last):
107        TypeError: undefined order, cannot get items from dict
108        >>> OrderedDict({1: 1}.items())
109        OrderedDict([(1, 1)])
110        >>> d = OrderedDict(((1, 3), (3, 2), (2, 1)))
111        >>> d
112        OrderedDict([(1, 3), (3, 2), (2, 1)])
113        >>> OrderedDict(d)
114        OrderedDict([(1, 3), (3, 2), (2, 1)])
115        """
116        self.strict = strict
117        dict.__init__(self)
118        if isinstance(init_val, OrderedDict):
119            self._sequence = init_val.keys()
120            dict.update(self, init_val)
121        elif isinstance(init_val, dict):
122            # we lose compatibility with other ordered dict types this way
123            raise TypeError('undefined order, cannot get items from dict')
124        else:
125            self._sequence = []
126            self.update(init_val)
127
128### Special methods ###
129
130    def __delitem__(self, key):
131        """
132        >>> d = OrderedDict(((1, 3), (3, 2), (2, 1)))
133        >>> del d[3]
134        >>> d
135        OrderedDict([(1, 3), (2, 1)])
136        >>> del d[3]
137        Traceback (most recent call last):
138        KeyError: 3
139        >>> d[3] = 2
140        >>> d
141        OrderedDict([(1, 3), (2, 1), (3, 2)])
142        >>> del d[0:1]
143        >>> d
144        OrderedDict([(2, 1), (3, 2)])
145        """
146        if isinstance(key, types.SliceType):
147            # FIXME: efficiency?
148            keys = self._sequence[key]
149            for entry in keys:
150                dict.__delitem__(self, entry)
151            del self._sequence[key]
152        else:
153            # do the dict.__delitem__ *first* as it raises
154            # the more appropriate error
155            dict.__delitem__(self, key)
156            self._sequence.remove(key)
157
158    def __eq__(self, other):
159        """
160        >>> d = OrderedDict(((1, 3), (3, 2), (2, 1)))
161        >>> d == OrderedDict(d)
162        True
163        >>> d == OrderedDict(((1, 3), (2, 1), (3, 2)))
164        False
165        >>> d == OrderedDict(((1, 0), (3, 2), (2, 1)))
166        False
167        >>> d == OrderedDict(((0, 3), (3, 2), (2, 1)))
168        False
169        >>> d == dict(d)
170        False
171        >>> d == False
172        False
173        """
174        if isinstance(other, OrderedDict):
175            # FIXME: efficiency?
176            #   Generate both item lists for each compare
177            return (self.items() == other.items())
178        else:
179            return False
180
181    def __lt__(self, other):
182        """
183        >>> d = OrderedDict(((1, 3), (3, 2), (2, 1)))
184        >>> c = OrderedDict(((0, 3), (3, 2), (2, 1)))
185        >>> c < d
186        True
187        >>> d < c
188        False
189        >>> d < dict(c)
190        Traceback (most recent call last):
191        TypeError: Can only compare with other OrderedDicts
192        """
193        if not isinstance(other, OrderedDict):
194            raise TypeError('Can only compare with other OrderedDicts')
195        # FIXME: efficiency?
196        #   Generate both item lists for each compare
197        return (self.items() < other.items())
198
199    def __le__(self, other):
200        """
201        >>> d = OrderedDict(((1, 3), (3, 2), (2, 1)))
202        >>> c = OrderedDict(((0, 3), (3, 2), (2, 1)))
203        >>> e = OrderedDict(d)
204        >>> c <= d
205        True
206        >>> d <= c
207        False
208        >>> d <= dict(c)
209        Traceback (most recent call last):
210        TypeError: Can only compare with other OrderedDicts
211        >>> d <= e
212        True
213        """
214        if not isinstance(other, OrderedDict):
215            raise TypeError('Can only compare with other OrderedDicts')
216        # FIXME: efficiency?
217        #   Generate both item lists for each compare
218        return (self.items() <= other.items())
219
220    def __ne__(self, other):
221        """
222        >>> d = OrderedDict(((1, 3), (3, 2), (2, 1)))
223        >>> d != OrderedDict(d)
224        False
225        >>> d != OrderedDict(((1, 3), (2, 1), (3, 2)))
226        True
227        >>> d != OrderedDict(((1, 0), (3, 2), (2, 1)))
228        True
229        >>> d == OrderedDict(((0, 3), (3, 2), (2, 1)))
230        False
231        >>> d != dict(d)
232        True
233        >>> d != False
234        True
235        """
236        if isinstance(other, OrderedDict):
237            # FIXME: efficiency?
238            #   Generate both item lists for each compare
239            return not (self.items() == other.items())
240        else:
241            return True
242
243    def __gt__(self, other):
244        """
245        >>> d = OrderedDict(((1, 3), (3, 2), (2, 1)))
246        >>> c = OrderedDict(((0, 3), (3, 2), (2, 1)))
247        >>> d > c
248        True
249        >>> c > d
250        False
251        >>> d > dict(c)
252        Traceback (most recent call last):
253        TypeError: Can only compare with other OrderedDicts
254        """
255        if not isinstance(other, OrderedDict):
256            raise TypeError('Can only compare with other OrderedDicts')
257        # FIXME: efficiency?
258        #   Generate both item lists for each compare
259        return (self.items() > other.items())
260
261    def __ge__(self, other):
262        """
263        >>> d = OrderedDict(((1, 3), (3, 2), (2, 1)))
264        >>> c = OrderedDict(((0, 3), (3, 2), (2, 1)))
265        >>> e = OrderedDict(d)
266        >>> c >= d
267        False
268        >>> d >= c
269        True
270        >>> d >= dict(c)
271        Traceback (most recent call last):
272        TypeError: Can only compare with other OrderedDicts
273        >>> e >= d
274        True
275        """
276        if not isinstance(other, OrderedDict):
277            raise TypeError('Can only compare with other OrderedDicts')
278        # FIXME: efficiency?
279        #   Generate both item lists for each compare
280        return (self.items() >= other.items())
281
282    def __repr__(self):
283        """
284        Used for __repr__ and __str__
[574adc7]285
[4bae1ef]286        >>> r1 = repr(OrderedDict((('a', 'b'), ('c', 'd'), ('e', 'f'))))
287        >>> r1
288        "OrderedDict([('a', 'b'), ('c', 'd'), ('e', 'f')])"
289        >>> r2 = repr(OrderedDict((('a', 'b'), ('e', 'f'), ('c', 'd'))))
290        >>> r2
291        "OrderedDict([('a', 'b'), ('e', 'f'), ('c', 'd')])"
292        >>> r1 == str(OrderedDict((('a', 'b'), ('c', 'd'), ('e', 'f'))))
293        True
294        >>> r2 == str(OrderedDict((('a', 'b'), ('e', 'f'), ('c', 'd'))))
295        True
296        """
297        return '%s([%s])' % (self.__class__.__name__, ', '.join(
298            ['(%r, %r)' % (key, self[key]) for key in self._sequence]))
299
300    def __setitem__(self, key, val):
301        """
302        Allows slice assignment, so long as the slice is an OrderedDict
303        >>> d = OrderedDict()
304        >>> d['a'] = 'b'
305        >>> d['b'] = 'a'
306        >>> d[3] = 12
307        >>> d
308        OrderedDict([('a', 'b'), ('b', 'a'), (3, 12)])
309        >>> d[:] = OrderedDict(((1, 2), (2, 3), (3, 4)))
310        >>> d
311        OrderedDict([(1, 2), (2, 3), (3, 4)])
312        >>> d[::2] = OrderedDict(((7, 8), (9, 10)))
313        >>> d
314        OrderedDict([(7, 8), (2, 3), (9, 10)])
315        >>> d = OrderedDict(((0, 1), (1, 2), (2, 3), (3, 4)))
316        >>> d[1:3] = OrderedDict(((1, 2), (5, 6), (7, 8)))
317        >>> d
318        OrderedDict([(0, 1), (1, 2), (5, 6), (7, 8), (3, 4)])
319        >>> d = OrderedDict(((0, 1), (1, 2), (2, 3), (3, 4)), strict=True)
320        >>> d[1:3] = OrderedDict(((1, 2), (5, 6), (7, 8)))
321        >>> d
322        OrderedDict([(0, 1), (1, 2), (5, 6), (7, 8), (3, 4)])
[574adc7]323
[4bae1ef]324        >>> a = OrderedDict(((0, 1), (1, 2), (2, 3)), strict=True)
325        >>> a[3] = 4
326        >>> a
327        OrderedDict([(0, 1), (1, 2), (2, 3), (3, 4)])
328        >>> a[::1] = OrderedDict([(0, 1), (1, 2), (2, 3), (3, 4)])
329        >>> a
330        OrderedDict([(0, 1), (1, 2), (2, 3), (3, 4)])
331        >>> a[:2] = OrderedDict([(0, 1), (1, 2), (2, 3), (3, 4), (4, 5)])
332        Traceback (most recent call last):
333        ValueError: slice assignment must be from unique keys
334        >>> a = OrderedDict(((0, 1), (1, 2), (2, 3)))
335        >>> a[3] = 4
336        >>> a
337        OrderedDict([(0, 1), (1, 2), (2, 3), (3, 4)])
338        >>> a[::1] = OrderedDict([(0, 1), (1, 2), (2, 3), (3, 4)])
339        >>> a
340        OrderedDict([(0, 1), (1, 2), (2, 3), (3, 4)])
341        >>> a[:2] = OrderedDict([(0, 1), (1, 2), (2, 3), (3, 4)])
342        >>> a
343        OrderedDict([(0, 1), (1, 2), (2, 3), (3, 4)])
344        >>> a[::-1] = OrderedDict([(0, 1), (1, 2), (2, 3), (3, 4)])
345        >>> a
346        OrderedDict([(3, 4), (2, 3), (1, 2), (0, 1)])
[574adc7]347
[4bae1ef]348        >>> d = OrderedDict([(0, 1), (1, 2), (2, 3), (3, 4)])
349        >>> d[:1] = 3
350        Traceback (most recent call last):
351        TypeError: slice assignment requires an OrderedDict
[574adc7]352
[4bae1ef]353        >>> d = OrderedDict([(0, 1), (1, 2), (2, 3), (3, 4)])
354        >>> d[:1] = OrderedDict([(9, 8)])
355        >>> d
356        OrderedDict([(9, 8), (1, 2), (2, 3), (3, 4)])
357        """
358        if isinstance(key, types.SliceType):
359            if not isinstance(val, OrderedDict):
360                # FIXME: allow a list of tuples?
361                raise TypeError('slice assignment requires an OrderedDict')
362            keys = self._sequence[key]
363            # NOTE: Could use ``range(*key.indices(len(self._sequence)))``
364            indexes = range(len(self._sequence))[key]
365            if key.step is None:
366                # NOTE: new slice may not be the same size as the one being
367                #   overwritten !
368                # NOTE: What is the algorithm for an impossible slice?
369                #   e.g. d[5:3]
370                pos = key.start or 0
371                del self[key]
372                newkeys = val.keys()
373                for k in newkeys:
374                    if k in self:
375                        if self.strict:
376                            raise ValueError('slice assignment must be from '
377                                'unique keys')
378                        else:
379                            # NOTE: This removes duplicate keys *first*
380                            #   so start position might have changed?
381                            del self[k]
382                self._sequence = (self._sequence[:pos] + newkeys +
383                    self._sequence[pos:])
384                dict.update(self, val)
385            else:
386                # extended slice - length of new slice must be the same
387                # as the one being replaced
388                if len(keys) != len(val):
389                    raise ValueError('attempt to assign sequence of size %s '
390                        'to extended slice of size %s' % (len(val), len(keys)))
391                # FIXME: efficiency?
392                del self[key]
393                item_list = zip(indexes, val.items())
394                # smallest indexes first - higher indexes not guaranteed to
395                # exist
396                item_list.sort()
397                for pos, (newkey, newval) in item_list:
398                    if self.strict and newkey in self:
399                        raise ValueError('slice assignment must be from unique'
400                            ' keys')
401                    self.insert(pos, newkey, newval)
402        else:
403            if key not in self:
404                self._sequence.append(key)
405            dict.__setitem__(self, key, val)
406
407    def __getitem__(self, key):
408        """
409        Allows slicing. Returns an OrderedDict if you slice.
410        >>> b = OrderedDict([(7, 0), (6, 1), (5, 2), (4, 3), (3, 4), (2, 5), (1, 6)])
411        >>> b[::-1]
412        OrderedDict([(1, 6), (2, 5), (3, 4), (4, 3), (5, 2), (6, 1), (7, 0)])
413        >>> b[2:5]
414        OrderedDict([(5, 2), (4, 3), (3, 4)])
415        >>> type(b[2:4])
416        <class '__main__.OrderedDict'>
417        """
418        if isinstance(key, types.SliceType):
419            # FIXME: does this raise the error we want?
420            keys = self._sequence[key]
421            # FIXME: efficiency?
422            return OrderedDict([(entry, self[entry]) for entry in keys])
423        else:
424            return dict.__getitem__(self, key)
425
426    __str__ = __repr__
427
428    def __setattr__(self, name, value):
429        """
430        Implemented so that accesses to ``sequence`` raise a warning and are
431        diverted to the new ``setkeys`` method.
432        """
433        if name == 'sequence':
434            warnings.warn('Use of the sequence attribute is deprecated.'
435                ' Use the keys method instead.', DeprecationWarning)
436            # NOTE: doesn't return anything
437            self.setkeys(value)
438        else:
439            # FIXME: do we want to allow arbitrary setting of attributes?
440            #   Or do we want to manage it?
441            object.__setattr__(self, name, value)
442
443    def __getattr__(self, name):
444        """
445        Implemented so that access to ``sequence`` raises a warning.
[574adc7]446
[4bae1ef]447        >>> d = OrderedDict()
448        >>> d.sequence
449        []
450        """
451        if name == 'sequence':
452            warnings.warn('Use of the sequence attribute is deprecated.'
453                ' Use the keys method instead.', DeprecationWarning)
454            # NOTE: Still (currently) returns a direct reference. Need to
455            #   because code that uses sequence will expect to be able to
456            #   mutate it in place.
457            return self._sequence
458        else:
459            # raise the appropriate error
460            raise AttributeError("OrderedDict has no '%s' attribute" % name)
461
462    def __deepcopy__(self, memo):
463        """
464        To allow deepcopy to work with OrderedDict.
[574adc7]465
[4bae1ef]466        >>> from copy import deepcopy
467        >>> a = OrderedDict([(1, 1), (2, 2), (3, 3)])
468        >>> a['test'] = {}
469        >>> b = deepcopy(a)
470        >>> b == a
471        True
472        >>> b is a
473        False
474        >>> a['test'] is b['test']
475        False
476        """
477        from copy import deepcopy
478        return self.__class__(deepcopy(self.items(), memo), self.strict)
479
480
481### Read-only methods ###
482
483    def copy(self):
484        """
485        >>> OrderedDict(((1, 3), (3, 2), (2, 1))).copy()
486        OrderedDict([(1, 3), (3, 2), (2, 1)])
487        """
488        return OrderedDict(self)
489
490    def items(self):
491        """
[574adc7]492        ``items`` returns a list of tuples representing all the
[4bae1ef]493        ``(key, value)`` pairs in the dictionary.
[574adc7]494
[4bae1ef]495        >>> d = OrderedDict(((1, 3), (3, 2), (2, 1)))
496        >>> d.items()
497        [(1, 3), (3, 2), (2, 1)]
498        >>> d.clear()
499        >>> d.items()
500        []
501        """
502        return zip(self._sequence, self.values())
503
504    def keys(self):
505        """
506        Return a list of keys in the ``OrderedDict``.
[574adc7]507
[4bae1ef]508        >>> d = OrderedDict(((1, 3), (3, 2), (2, 1)))
509        >>> d.keys()
510        [1, 3, 2]
511        """
512        return self._sequence[:]
513
514    def values(self, values=None):
515        """
516        Return a list of all the values in the OrderedDict.
[574adc7]517
[4bae1ef]518        Optionally you can pass in a list of values, which will replace the
519        current list. The value list must be the same len as the OrderedDict.
[574adc7]520
[4bae1ef]521        >>> d = OrderedDict(((1, 3), (3, 2), (2, 1)))
522        >>> d.values()
523        [3, 2, 1]
524        """
525        return [self[key] for key in self._sequence]
526
527    def iteritems(self):
528        """
529        >>> ii = OrderedDict(((1, 3), (3, 2), (2, 1))).iteritems()
530        >>> ii.next()
531        (1, 3)
532        >>> ii.next()
533        (3, 2)
534        >>> ii.next()
535        (2, 1)
536        >>> ii.next()
537        Traceback (most recent call last):
538        StopIteration
539        """
540        def make_iter(self=self):
541            keys = self.iterkeys()
542            while True:
543                key = keys.next()
544                yield (key, self[key])
545        return make_iter()
546
547    def iterkeys(self):
548        """
549        >>> ii = OrderedDict(((1, 3), (3, 2), (2, 1))).iterkeys()
550        >>> ii.next()
551        1
552        >>> ii.next()
553        3
554        >>> ii.next()
555        2
556        >>> ii.next()
557        Traceback (most recent call last):
558        StopIteration
559        """
560        return iter(self._sequence)
561
562    __iter__ = iterkeys
563
564    def itervalues(self):
565        """
566        >>> iv = OrderedDict(((1, 3), (3, 2), (2, 1))).itervalues()
567        >>> iv.next()
568        3
569        >>> iv.next()
570        2
571        >>> iv.next()
572        1
573        >>> iv.next()
574        Traceback (most recent call last):
575        StopIteration
576        """
577        def make_iter(self=self):
578            keys = self.iterkeys()
579            while True:
580                yield self[keys.next()]
581        return make_iter()
582
583### Read-write methods ###
584
585    def clear(self):
586        """
587        >>> d = OrderedDict(((1, 3), (3, 2), (2, 1)))
588        >>> d.clear()
589        >>> d
590        OrderedDict([])
591        """
592        dict.clear(self)
593        self._sequence = []
594
595    def pop(self, key, *args):
596        """
597        No dict.pop in Python 2.2, gotta reimplement it
[574adc7]598
[4bae1ef]599        >>> d = OrderedDict(((1, 3), (3, 2), (2, 1)))
600        >>> d.pop(3)
601        2
602        >>> d
603        OrderedDict([(1, 3), (2, 1)])
604        >>> d.pop(4)
605        Traceback (most recent call last):
606        KeyError: 4
607        >>> d.pop(4, 0)
608        0
609        >>> d.pop(4, 0, 1)
610        Traceback (most recent call last):
611        TypeError: pop expected at most 2 arguments, got 3
612        """
613        if len(args) > 1:
[574adc7]614            raise TypeError('pop expected at most 2 arguments, got %s' %
[4bae1ef]615                (len(args) + 1))
616        if key in self:
617            val = self[key]
618            del self[key]
619        else:
620            try:
621                val = args[0]
622            except IndexError:
623                raise KeyError(key)
624        return val
625
626    def popitem(self, i=-1):
627        """
628        Delete and return an item specified by index, not a random one as in
629        dict. The index is -1 by default (the last item).
[574adc7]630
[4bae1ef]631        >>> d = OrderedDict(((1, 3), (3, 2), (2, 1)))
632        >>> d.popitem()
633        (2, 1)
634        >>> d
635        OrderedDict([(1, 3), (3, 2)])
636        >>> d.popitem(0)
637        (1, 3)
638        >>> OrderedDict().popitem()
639        Traceback (most recent call last):
640        KeyError: 'popitem(): dictionary is empty'
641        >>> d.popitem(2)
642        Traceback (most recent call last):
643        IndexError: popitem(): index 2 not valid
644        """
645        if not self._sequence:
646            raise KeyError('popitem(): dictionary is empty')
647        try:
648            key = self._sequence[i]
649        except IndexError:
650            raise IndexError('popitem(): index %s not valid' % i)
651        return (key, self.pop(key))
652
653    def setdefault(self, key, defval = None):
654        """
655        >>> d = OrderedDict(((1, 3), (3, 2), (2, 1)))
656        >>> d.setdefault(1)
657        3
658        >>> d.setdefault(4) is None
659        True
660        >>> d
661        OrderedDict([(1, 3), (3, 2), (2, 1), (4, None)])
662        >>> d.setdefault(5, 0)
663        0
664        >>> d
665        OrderedDict([(1, 3), (3, 2), (2, 1), (4, None), (5, 0)])
666        """
667        if key in self:
668            return self[key]
669        else:
670            self[key] = defval
671            return defval
672
673    def update(self, from_od):
674        """
675        Update from another OrderedDict or sequence of (key, value) pairs
[574adc7]676
[4bae1ef]677        >>> d = OrderedDict(((1, 0), (0, 1)))
678        >>> d.update(OrderedDict(((1, 3), (3, 2), (2, 1))))
679        >>> d
680        OrderedDict([(1, 3), (0, 1), (3, 2), (2, 1)])
681        >>> d.update({4: 4})
682        Traceback (most recent call last):
683        TypeError: undefined order, cannot get items from dict
684        >>> d.update((4, 4))
685        Traceback (most recent call last):
686        TypeError: cannot convert dictionary update sequence element "4" to a 2-item sequence
687        """
688        if isinstance(from_od, OrderedDict):
689            for key, val in from_od.items():
690                self[key] = val
691        elif isinstance(from_od, dict):
692            # we lose compatibility with other ordered dict types this way
693            raise TypeError('undefined order, cannot get items from dict')
694        else:
695            # FIXME: efficiency?
696            # sequence of 2-item sequences, or error
697            for item in from_od:
698                try:
699                    key, val = item
700                except TypeError:
701                    raise TypeError('cannot convert dictionary update'
702                        ' sequence element "%s" to a 2-item sequence' % item)
703                self[key] = val
704
705    def rename(self, old_key, new_key):
706        """
707        Rename the key for a given value, without modifying sequence order.
[574adc7]708
[4bae1ef]709        For the case where new_key already exists this raise an exception,
710        since if new_key exists, it is ambiguous as to what happens to the
711        associated values, and the position of new_key in the sequence.
[574adc7]712
[4bae1ef]713        >>> od = OrderedDict()
714        >>> od['a'] = 1
715        >>> od['b'] = 2
716        >>> od.items()
717        [('a', 1), ('b', 2)]
718        >>> od.rename('b', 'c')
719        >>> od.items()
720        [('a', 1), ('c', 2)]
721        >>> od.rename('c', 'a')
722        Traceback (most recent call last):
723        ValueError: New key already exists: 'a'
724        >>> od.rename('d', 'b')
725        Traceback (most recent call last):
726        KeyError: 'd'
727        """
728        if new_key == old_key:
729            # no-op
730            return
731        if new_key in self:
732            raise ValueError("New key already exists: %r" % new_key)
733        # rename sequence entry
[574adc7]734        value = self[old_key]
[4bae1ef]735        old_idx = self._sequence.index(old_key)
736        self._sequence[old_idx] = new_key
737        # rename internal dict entry
738        dict.__delitem__(self, old_key)
739        dict.__setitem__(self, new_key, value)
740
741    def setitems(self, items):
742        """
743        This method allows you to set the items in the dict.
[574adc7]744
[4bae1ef]745        It takes a list of tuples - of the same sort returned by the ``items``
746        method.
[574adc7]747
[4bae1ef]748        >>> d = OrderedDict()
749        >>> d.setitems(((3, 1), (2, 3), (1, 2)))
750        >>> d
751        OrderedDict([(3, 1), (2, 3), (1, 2)])
752        """
753        self.clear()
754        # FIXME: this allows you to pass in an OrderedDict as well :-)
755        self.update(items)
756
757    def setkeys(self, keys):
758        """
759        ``setkeys`` all ows you to pass in a new list of keys which will
760        replace the current set. This must contain the same set of keys, but
761        need not be in the same order.
[574adc7]762
[4bae1ef]763        If you pass in new keys that don't match, a ``KeyError`` will be
764        raised.
[574adc7]765
[4bae1ef]766        >>> d = OrderedDict(((1, 3), (3, 2), (2, 1)))
767        >>> d.keys()
768        [1, 3, 2]
769        >>> d.setkeys((1, 2, 3))
770        >>> d
771        OrderedDict([(1, 3), (2, 1), (3, 2)])
772        >>> d.setkeys(['a', 'b', 'c'])
773        Traceback (most recent call last):
774        KeyError: 'Keylist is not the same as current keylist.'
775        """
776        # FIXME: Efficiency? (use set for Python 2.4 :-)
777        # NOTE: list(keys) rather than keys[:] because keys[:] returns
778        #   a tuple, if keys is a tuple.
779        kcopy = list(keys)
780        kcopy.sort()
781        self._sequence.sort()
782        if kcopy != self._sequence:
783            raise KeyError('Keylist is not the same as current keylist.')
784        # NOTE: This makes the _sequence attribute a new object, instead
785        #       of changing it in place.
786        # FIXME: efficiency?
787        self._sequence = list(keys)
788
789    def setvalues(self, values):
790        """
791        You can pass in a list of values, which will replace the
792        current list. The value list must be the same len as the OrderedDict.
[574adc7]793
[4bae1ef]794        (Or a ``ValueError`` is raised.)
[574adc7]795
[4bae1ef]796        >>> d = OrderedDict(((1, 3), (3, 2), (2, 1)))
797        >>> d.setvalues((1, 2, 3))
798        >>> d
799        OrderedDict([(1, 1), (3, 2), (2, 3)])
800        >>> d.setvalues([6])
801        Traceback (most recent call last):
802        ValueError: Value list is not the same length as the OrderedDict.
803        """
804        if len(values) != len(self):
805            # FIXME: correct error to raise?
806            raise ValueError('Value list is not the same length as the '
807                'OrderedDict.')
808        self.update(zip(self, values))
809
810### Sequence Methods ###
811
812    def index(self, key):
813        """
814        Return the position of the specified key in the OrderedDict.
[574adc7]815
[4bae1ef]816        >>> d = OrderedDict(((1, 3), (3, 2), (2, 1)))
817        >>> d.index(3)
818        1
819        >>> d.index(4)
820        Traceback (most recent call last):
821        ValueError: list.index(x): x not in list
822        """
823        return self._sequence.index(key)
824
825    def insert(self, index, key, value):
826        """
827        Takes ``index``, ``key``, and ``value`` as arguments.
[574adc7]828
[4bae1ef]829        Sets ``key`` to ``value``, so that ``key`` is at position ``index`` in
830        the OrderedDict.
[574adc7]831
[4bae1ef]832        >>> d = OrderedDict(((1, 3), (3, 2), (2, 1)))
833        >>> d.insert(0, 4, 0)
834        >>> d
835        OrderedDict([(4, 0), (1, 3), (3, 2), (2, 1)])
836        >>> d.insert(0, 2, 1)
837        >>> d
838        OrderedDict([(2, 1), (4, 0), (1, 3), (3, 2)])
839        >>> d.insert(8, 8, 1)
840        >>> d
841        OrderedDict([(2, 1), (4, 0), (1, 3), (3, 2), (8, 1)])
842        """
843        if key in self:
844            # FIXME: efficiency?
845            del self[key]
846        self._sequence.insert(index, key)
847        dict.__setitem__(self, key, value)
848
849    def reverse(self):
850        """
851        Reverse the order of the OrderedDict.
[574adc7]852
[4bae1ef]853        >>> d = OrderedDict(((1, 3), (3, 2), (2, 1)))
854        >>> d.reverse()
855        >>> d
856        OrderedDict([(2, 1), (3, 2), (1, 3)])
857        """
858        self._sequence.reverse()
859
860    def sort(self, *args, **kwargs):
861        """
862        Sort the key order in the OrderedDict.
[574adc7]863
[4bae1ef]864        This method takes the same arguments as the ``list.sort`` method on
865        your version of Python.
[574adc7]866
[4bae1ef]867        >>> d = OrderedDict(((4, 1), (2, 2), (3, 3), (1, 4)))
868        >>> d.sort()
869        >>> d
870        OrderedDict([(1, 4), (2, 2), (3, 3), (4, 1)])
871        """
872        self._sequence.sort(*args, **kwargs)
873
874class Keys(object):
875    # FIXME: should this object be a subclass of list?
876    """
877    Custom object for accessing the keys of an OrderedDict.
[574adc7]878
[4bae1ef]879    Can be called like the normal ``OrderedDict.keys`` method, but also
880    supports indexing and sequence methods.
881    """
882
883    def __init__(self, main):
884        self._main = main
885
886    def __call__(self):
887        """Pretend to be the keys method."""
888        return self._main._keys()
889
890    def __getitem__(self, index):
891        """Fetch the key at position i."""
892        # NOTE: this automatically supports slicing :-)
893        return self._main._sequence[index]
894
895    def __setitem__(self, index, name):
896        """
897        You cannot assign to keys, but you can do slice assignment to re-order
898        them.
[574adc7]899
[4bae1ef]900        You can only do slice assignment if the new set of keys is a reordering
901        of the original set.
902        """
903        if isinstance(index, types.SliceType):
904            # FIXME: efficiency?
905            # check length is the same
906            indexes = range(len(self._main._sequence))[index]
907            if len(indexes) != len(name):
908                raise ValueError('attempt to assign sequence of size %s '
909                    'to slice of size %s' % (len(name), len(indexes)))
910            # check they are the same keys
911            # FIXME: Use set
912            old_keys = self._main._sequence[index]
913            new_keys = list(name)
914            old_keys.sort()
915            new_keys.sort()
916            if old_keys != new_keys:
917                raise KeyError('Keylist is not the same as current keylist.')
918            orig_vals = [self._main[k] for k in name]
919            del self._main[index]
920            vals = zip(indexes, name, orig_vals)
921            vals.sort()
922            for i, k, v in vals:
923                if self._main.strict and k in self._main:
924                    raise ValueError('slice assignment must be from '
925                        'unique keys')
926                self._main.insert(i, k, v)
927        else:
928            raise ValueError('Cannot assign to keys')
929
930    ### following methods pinched from UserList and adapted ###
931    def __repr__(self): return repr(self._main._sequence)
932
933    # FIXME: do we need to check if we are comparing with another ``Keys``
934    #   object? (like the __cast method of UserList)
935    def __lt__(self, other): return self._main._sequence <  other
936    def __le__(self, other): return self._main._sequence <= other
937    def __eq__(self, other): return self._main._sequence == other
938    def __ne__(self, other): return self._main._sequence != other
939    def __gt__(self, other): return self._main._sequence >  other
940    def __ge__(self, other): return self._main._sequence >= other
941    # FIXME: do we need __cmp__ as well as rich comparisons?
942    def __cmp__(self, other): return cmp(self._main._sequence, other)
943
944    def __contains__(self, item): return item in self._main._sequence
945    def __len__(self): return len(self._main._sequence)
946    def __iter__(self): return self._main.iterkeys()
947    def count(self, item): return self._main._sequence.count(item)
948    def index(self, item, *args): return self._main._sequence.index(item, *args)
949    def reverse(self): self._main._sequence.reverse()
950    def sort(self, *args, **kwds): self._main._sequence.sort(*args, **kwds)
951    def __mul__(self, n): return self._main._sequence*n
952    __rmul__ = __mul__
953    def __add__(self, other): return self._main._sequence + other
954    def __radd__(self, other): return other + self._main._sequence
955
956    ## following methods not implemented for keys ##
957    def __delitem__(self, i): raise TypeError('Can\'t delete items from keys')
958    def __iadd__(self, other): raise TypeError('Can\'t add in place to keys')
959    def __imul__(self, n): raise TypeError('Can\'t multiply keys in place')
960    def append(self, item): raise TypeError('Can\'t append items to keys')
961    def insert(self, i, item): raise TypeError('Can\'t insert items into keys')
962    def pop(self, i=-1): raise TypeError('Can\'t pop items from keys')
963    def remove(self, item): raise TypeError('Can\'t remove items from keys')
964    def extend(self, other): raise TypeError('Can\'t extend keys')
965
966class Items(object):
967    """
968    Custom object for accessing the items of an OrderedDict.
[574adc7]969
[4bae1ef]970    Can be called like the normal ``OrderedDict.items`` method, but also
971    supports indexing and sequence methods.
972    """
973
974    def __init__(self, main):
975        self._main = main
976
977    def __call__(self):
978        """Pretend to be the items method."""
979        return self._main._items()
980
981    def __getitem__(self, index):
982        """Fetch the item at position i."""
983        if isinstance(index, types.SliceType):
984            # fetching a slice returns an OrderedDict
985            return self._main[index].items()
986        key = self._main._sequence[index]
987        return (key, self._main[key])
988
989    def __setitem__(self, index, item):
990        """Set item at position i to item."""
991        if isinstance(index, types.SliceType):
992            # NOTE: item must be an iterable (list of tuples)
993            self._main[index] = OrderedDict(item)
994        else:
995            # FIXME: Does this raise a sensible error?
996            orig = self._main.keys[index]
997            key, value = item
998            if self._main.strict and key in self and (key != orig):
999                raise ValueError('slice assignment must be from '
1000                        'unique keys')
1001            # delete the current one
1002            del self._main[self._main._sequence[index]]
1003            self._main.insert(index, key, value)
1004
1005    def __delitem__(self, i):
1006        """Delete the item at position i."""
1007        key = self._main._sequence[i]
1008        if isinstance(i, types.SliceType):
1009            for k in key:
1010                # FIXME: efficiency?
1011                del self._main[k]
1012        else:
1013            del self._main[key]
1014
1015    ### following methods pinched from UserList and adapted ###
1016    def __repr__(self): return repr(self._main.items())
1017
1018    # FIXME: do we need to check if we are comparing with another ``Items``
1019    #   object? (like the __cast method of UserList)
1020    def __lt__(self, other): return self._main.items() <  other
1021    def __le__(self, other): return self._main.items() <= other
1022    def __eq__(self, other): return self._main.items() == other
1023    def __ne__(self, other): return self._main.items() != other
1024    def __gt__(self, other): return self._main.items() >  other
1025    def __ge__(self, other): return self._main.items() >= other
1026    def __cmp__(self, other): return cmp(self._main.items(), other)
1027
1028    def __contains__(self, item): return item in self._main.items()
1029    def __len__(self): return len(self._main._sequence) # easier :-)
1030    def __iter__(self): return self._main.iteritems()
1031    def count(self, item): return self._main.items().count(item)
1032    def index(self, item, *args): return self._main.items().index(item, *args)
1033    def reverse(self): self._main.reverse()
1034    def sort(self, *args, **kwds): self._main.sort(*args, **kwds)
1035    def __mul__(self, n): return self._main.items()*n
1036    __rmul__ = __mul__
1037    def __add__(self, other): return self._main.items() + other
1038    def __radd__(self, other): return other + self._main.items()
1039
1040    def append(self, item):
1041        """Add an item to the end."""
1042        # FIXME: this is only append if the key isn't already present
1043        key, value = item
1044        self._main[key] = value
1045
1046    def insert(self, i, item):
1047        key, value = item
1048        self._main.insert(i, key, value)
1049
1050    def pop(self, i=-1):
1051        key = self._main._sequence[i]
1052        return (key, self._main.pop(key))
1053
1054    def remove(self, item):
1055        key, value = item
1056        try:
1057            assert value == self._main[key]
1058        except (KeyError, AssertionError):
1059            raise ValueError('ValueError: list.remove(x): x not in list')
1060        else:
1061            del self._main[key]
1062
1063    def extend(self, other):
1064        # FIXME: is only a true extend if none of the keys already present
1065        for item in other:
1066            key, value = item
1067            self._main[key] = value
1068
1069    def __iadd__(self, other):
1070        self.extend(other)
1071
1072    ## following methods not implemented for items ##
1073
1074    def __imul__(self, n): raise TypeError('Can\'t multiply items in place')
1075
1076class Values(object):
1077    """
1078    Custom object for accessing the values of an OrderedDict.
[574adc7]1079
[4bae1ef]1080    Can be called like the normal ``OrderedDict.values`` method, but also
1081    supports indexing and sequence methods.
1082    """
1083
1084    def __init__(self, main):
1085        self._main = main
1086
1087    def __call__(self):
1088        """Pretend to be the values method."""
1089        return self._main._values()
1090
1091    def __getitem__(self, index):
1092        """Fetch the value at position i."""
1093        if isinstance(index, types.SliceType):
1094            return [self._main[key] for key in self._main._sequence[index]]
1095        else:
1096            return self._main[self._main._sequence[index]]
1097
1098    def __setitem__(self, index, value):
1099        """
1100        Set the value at position i to value.
[574adc7]1101
[4bae1ef]1102        You can only do slice assignment to values if you supply a sequence of
1103        equal length to the slice you are replacing.
1104        """
1105        if isinstance(index, types.SliceType):
1106            keys = self._main._sequence[index]
1107            if len(keys) != len(value):
1108                raise ValueError('attempt to assign sequence of size %s '
1109                    'to slice of size %s' % (len(name), len(keys)))
1110            # FIXME: efficiency?  Would be better to calculate the indexes
1111            #   directly from the slice object
1112            # NOTE: the new keys can collide with existing keys (or even
1113            #   contain duplicates) - these will overwrite
1114            for key, val in zip(keys, value):
1115                self._main[key] = val
1116        else:
1117            self._main[self._main._sequence[index]] = value
1118
1119    ### following methods pinched from UserList and adapted ###
1120    def __repr__(self): return repr(self._main.values())
1121
1122    # FIXME: do we need to check if we are comparing with another ``Values``
1123    #   object? (like the __cast method of UserList)
1124    def __lt__(self, other): return self._main.values() <  other
1125    def __le__(self, other): return self._main.values() <= other
1126    def __eq__(self, other): return self._main.values() == other
1127    def __ne__(self, other): return self._main.values() != other
1128    def __gt__(self, other): return self._main.values() >  other
1129    def __ge__(self, other): return self._main.values() >= other
1130    def __cmp__(self, other): return cmp(self._main.values(), other)
1131
1132    def __contains__(self, item): return item in self._main.values()
1133    def __len__(self): return len(self._main._sequence) # easier :-)
1134    def __iter__(self): return self._main.itervalues()
1135    def count(self, item): return self._main.values().count(item)
1136    def index(self, item, *args): return self._main.values().index(item, *args)
1137
1138    def reverse(self):
1139        """Reverse the values"""
1140        vals = self._main.values()
1141        vals.reverse()
1142        # FIXME: efficiency
1143        self[:] = vals
1144
1145    def sort(self, *args, **kwds):
1146        """Sort the values."""
1147        vals = self._main.values()
1148        vals.sort(*args, **kwds)
1149        self[:] = vals
1150
1151    def __mul__(self, n): return self._main.values()*n
1152    __rmul__ = __mul__
1153    def __add__(self, other): return self._main.values() + other
1154    def __radd__(self, other): return other + self._main.values()
1155
1156    ## following methods not implemented for values ##
1157    def __delitem__(self, i): raise TypeError('Can\'t delete items from values')
1158    def __iadd__(self, other): raise TypeError('Can\'t add in place to values')
1159    def __imul__(self, n): raise TypeError('Can\'t multiply values in place')
1160    def append(self, item): raise TypeError('Can\'t append items to values')
1161    def insert(self, i, item): raise TypeError('Can\'t insert items into values')
1162    def pop(self, i=-1): raise TypeError('Can\'t pop items from values')
1163    def remove(self, item): raise TypeError('Can\'t remove items from values')
1164    def extend(self, other): raise TypeError('Can\'t extend values')
1165
1166class SequenceOrderedDict(OrderedDict):
1167    """
1168    Experimental version of OrderedDict that has a custom object for ``keys``,
1169    ``values``, and ``items``.
[574adc7]1170
[4bae1ef]1171    These are callable sequence objects that work as methods, or can be
1172    manipulated directly as sequences.
[574adc7]1173
[4bae1ef]1174    Test for ``keys``, ``items`` and ``values``.
[574adc7]1175
[4bae1ef]1176    >>> d = SequenceOrderedDict(((1, 2), (2, 3), (3, 4)))
1177    >>> d
1178    SequenceOrderedDict([(1, 2), (2, 3), (3, 4)])
1179    >>> d.keys
1180    [1, 2, 3]
1181    >>> d.keys()
1182    [1, 2, 3]
1183    >>> d.setkeys((3, 2, 1))
1184    >>> d
1185    SequenceOrderedDict([(3, 4), (2, 3), (1, 2)])
1186    >>> d.setkeys((1, 2, 3))
1187    >>> d.keys[0]
1188    1
1189    >>> d.keys[:]
1190    [1, 2, 3]
1191    >>> d.keys[-1]
1192    3
1193    >>> d.keys[-2]
1194    2
1195    >>> d.keys[0:2] = [2, 1]
1196    >>> d
1197    SequenceOrderedDict([(2, 3), (1, 2), (3, 4)])
1198    >>> d.keys.reverse()
1199    >>> d.keys
1200    [3, 1, 2]
1201    >>> d.keys = [1, 2, 3]
1202    >>> d
1203    SequenceOrderedDict([(1, 2), (2, 3), (3, 4)])
1204    >>> d.keys = [3, 1, 2]
1205    >>> d
1206    SequenceOrderedDict([(3, 4), (1, 2), (2, 3)])
1207    >>> a = SequenceOrderedDict()
1208    >>> b = SequenceOrderedDict()
1209    >>> a.keys == b.keys
1210    1
1211    >>> a['a'] = 3
1212    >>> a.keys == b.keys
1213    0
1214    >>> b['a'] = 3
1215    >>> a.keys == b.keys
1216    1
1217    >>> b['b'] = 3
1218    >>> a.keys == b.keys
1219    0
1220    >>> a.keys > b.keys
1221    0
1222    >>> a.keys < b.keys
1223    1
1224    >>> 'a' in a.keys
1225    1
1226    >>> len(b.keys)
1227    2
1228    >>> 'c' in d.keys
1229    0
1230    >>> 1 in d.keys
1231    1
1232    >>> [v for v in d.keys]
1233    [3, 1, 2]
1234    >>> d.keys.sort()
1235    >>> d.keys
1236    [1, 2, 3]
1237    >>> d = SequenceOrderedDict(((1, 2), (2, 3), (3, 4)), strict=True)
1238    >>> d.keys[::-1] = [1, 2, 3]
1239    >>> d
1240    SequenceOrderedDict([(3, 4), (2, 3), (1, 2)])
1241    >>> d.keys[:2]
1242    [3, 2]
1243    >>> d.keys[:2] = [1, 3]
1244    Traceback (most recent call last):
1245    KeyError: 'Keylist is not the same as current keylist.'
1246
1247    >>> d = SequenceOrderedDict(((1, 2), (2, 3), (3, 4)))
1248    >>> d
1249    SequenceOrderedDict([(1, 2), (2, 3), (3, 4)])
1250    >>> d.values
1251    [2, 3, 4]
1252    >>> d.values()
1253    [2, 3, 4]
1254    >>> d.setvalues((4, 3, 2))
1255    >>> d
1256    SequenceOrderedDict([(1, 4), (2, 3), (3, 2)])
1257    >>> d.values[::-1]
1258    [2, 3, 4]
1259    >>> d.values[0]
1260    4
1261    >>> d.values[-2]
1262    3
1263    >>> del d.values[0]
1264    Traceback (most recent call last):
1265    TypeError: Can't delete items from values
1266    >>> d.values[::2] = [2, 4]
1267    >>> d
1268    SequenceOrderedDict([(1, 2), (2, 3), (3, 4)])
1269    >>> 7 in d.values
1270    0
1271    >>> len(d.values)
1272    3
1273    >>> [val for val in d.values]
1274    [2, 3, 4]
1275    >>> d.values[-1] = 2
1276    >>> d.values.count(2)
1277    2
1278    >>> d.values.index(2)
1279    0
1280    >>> d.values[-1] = 7
1281    >>> d.values
1282    [2, 3, 7]
1283    >>> d.values.reverse()
1284    >>> d.values
1285    [7, 3, 2]
1286    >>> d.values.sort()
1287    >>> d.values
1288    [2, 3, 7]
1289    >>> d.values.append('anything')
1290    Traceback (most recent call last):
1291    TypeError: Can't append items to values
1292    >>> d.values = (1, 2, 3)
1293    >>> d
1294    SequenceOrderedDict([(1, 1), (2, 2), (3, 3)])
[574adc7]1295
[4bae1ef]1296    >>> d = SequenceOrderedDict(((1, 2), (2, 3), (3, 4)))
1297    >>> d
1298    SequenceOrderedDict([(1, 2), (2, 3), (3, 4)])
1299    >>> d.items()
1300    [(1, 2), (2, 3), (3, 4)]
1301    >>> d.setitems([(3, 4), (2 ,3), (1, 2)])
1302    >>> d
1303    SequenceOrderedDict([(3, 4), (2, 3), (1, 2)])
1304    >>> d.items[0]
1305    (3, 4)
1306    >>> d.items[:-1]
1307    [(3, 4), (2, 3)]
1308    >>> d.items[1] = (6, 3)
1309    >>> d.items
1310    [(3, 4), (6, 3), (1, 2)]
1311    >>> d.items[1:2] = [(9, 9)]
1312    >>> d
1313    SequenceOrderedDict([(3, 4), (9, 9), (1, 2)])
1314    >>> del d.items[1:2]
1315    >>> d
1316    SequenceOrderedDict([(3, 4), (1, 2)])
1317    >>> (3, 4) in d.items
1318    1
1319    >>> (4, 3) in d.items
1320    0
1321    >>> len(d.items)
1322    2
1323    >>> [v for v in d.items]
1324    [(3, 4), (1, 2)]
1325    >>> d.items.count((3, 4))
1326    1
1327    >>> d.items.index((1, 2))
1328    1
1329    >>> d.items.index((2, 1))
1330    Traceback (most recent call last):
1331    ValueError: list.index(x): x not in list
1332    >>> d.items.reverse()
1333    >>> d.items
1334    [(1, 2), (3, 4)]
1335    >>> d.items.reverse()
1336    >>> d.items.sort()
1337    >>> d.items
1338    [(1, 2), (3, 4)]
1339    >>> d.items.append((5, 6))
1340    >>> d.items
1341    [(1, 2), (3, 4), (5, 6)]
1342    >>> d.items.insert(0, (0, 0))
1343    >>> d.items
1344    [(0, 0), (1, 2), (3, 4), (5, 6)]
1345    >>> d.items.insert(-1, (7, 8))
1346    >>> d.items
1347    [(0, 0), (1, 2), (3, 4), (7, 8), (5, 6)]
1348    >>> d.items.pop()
1349    (5, 6)
1350    >>> d.items
1351    [(0, 0), (1, 2), (3, 4), (7, 8)]
1352    >>> d.items.remove((1, 2))
1353    >>> d.items
1354    [(0, 0), (3, 4), (7, 8)]
1355    >>> d.items.extend([(1, 2), (5, 6)])
1356    >>> d.items
1357    [(0, 0), (3, 4), (7, 8), (1, 2), (5, 6)]
1358    """
1359
1360    def __init__(self, init_val=(), strict=True):
1361        OrderedDict.__init__(self, init_val, strict=strict)
1362        self._keys = self.keys
1363        self._values = self.values
1364        self._items = self.items
1365        self.keys = Keys(self)
1366        self.values = Values(self)
1367        self.items = Items(self)
1368        self._att_dict = {
1369            'keys': self.setkeys,
1370            'items': self.setitems,
1371            'values': self.setvalues,
1372        }
1373
1374    def __setattr__(self, name, value):
1375        """Protect keys, items, and values."""
1376        if not '_att_dict' in self.__dict__:
1377            object.__setattr__(self, name, value)
1378        else:
1379            try:
1380                fun = self._att_dict[name]
1381            except KeyError:
1382                OrderedDict.__setattr__(self, name, value)
1383            else:
1384                fun(value)
1385
1386if __name__ == '__main__':
1387    if INTP_VER < (2, 3):
1388        raise RuntimeError("Tests require Python v.2.3 or later")
1389    # turn off warnings for tests
1390    warnings.filterwarnings('ignore')
1391    # run the code tests in doctest format
1392    import doctest
1393    m = sys.modules.get('__main__')
1394    globs = m.__dict__.copy()
1395    globs.update({
1396        'INTP_VER': INTP_VER,
1397    })
1398    doctest.testmod(m, globs=globs)
1399
Note: See TracBrowser for help on using the repository browser.