src/dataTools/odict.py

   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"""
  18 from __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 129 2005-09-12 18:15:28Z teknico $'
  26
  27 __version__ = '0.2.2'
  28
  29 __all__ = ['OrderedDict', 'SequenceOrderedDict']
  30
  31 import sys
  32 INTP_VER = sys.version_info[:2]
  33 if INTP_VER < (2, 2):
  34     raise RuntimeError("Python v.2.2 or later required")
  35
  36 import types, warnings
  37
  38 class OrderedDict(dict):
  39     """
  40     A class of dictionary that keeps the insertion order of keys.
  41
  42     All appropriate methods return keys, items, or values in an ordered way.
  43
  44     All normal dictionary methods are available. Update and comparison is
  45     restricted to other OrderedDict objects.
  46
  47     Various sequence methods are available, including the ability to explicitly
  48     mutate the key ordering.
  49
  50     __contains__ tests:
  51
  52     >>> d = OrderedDict(((1, 3),))
  53     >>> 1 in d
  54     1
  55     >>> 4 in d
  56     0
  57
  58     __getitem__ tests:
  59
  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
  65
  66     __len__ tests:
  67
  68     >>> len(OrderedDict())
  69     0
  70     >>> len(OrderedDict(((1, 3), (3, 2), (2, 1))))
  71     3
  72
  73     get tests:
  74
  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)])
  84
  85     has_key tests:
  86
  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.
  98
  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.
 102
 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__
 285
 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)])
 323
 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)])
 347
 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
 352
 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.
 446
 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.
 465
 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         """
 492         ``items`` returns a list of tuples representing all the
 493         ``(key, value)`` pairs in the dictionary.
 494
 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``.
 507
 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.
 517
 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.
 520
 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
 598
 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:
 614             raise TypeError, ('pop expected at most 2 arguments, got %s' %
 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).
 630
 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
 676
 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.
 708
 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.
 712
 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
 734         value = self[old_key]
 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.
 744
 745         It takes a list of tuples - of the same sort returned by the ``items``
 746         method.
 747
 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.
 762
 763         If you pass in new keys that don't match, a ``KeyError`` will be
 764         raised.
 765
 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.
 793
 794         (Or a ``ValueError`` is raised.)
 795
 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.
 815
 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.
 828
 829         Sets ``key`` to ``value``, so that ``key`` is at position ``index`` in
 830         the OrderedDict.
 831
 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.
 852
 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.
 863
 864         This method takes the same arguments as the ``list.sort`` method on
 865         your version of Python.
 866
 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
 874 class Keys(object):
 875     # FIXME: should this object be a subclass of list?
 876     """
 877     Custom object for accessing the keys of an OrderedDict.
 878
 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.
 899
 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
 966 class Items(object):
 967     """
 968     Custom object for accessing the items of an OrderedDict.
 969
 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
1076 class Values(object):
1077     """
1078     Custom object for accessing the values of an OrderedDict.
1079
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.
1101
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
1166 class SequenceOrderedDict(OrderedDict):
1167     """
1168     Experimental version of OrderedDict that has a custom object for ``keys``,
1169     ``values``, and ``items``.
1170
1171     These are callable sequence objects that work as methods, or can be
1172     manipulated directly as sequences.
1173
1174     Test for ``keys``, ``items`` and ``values``.
1175
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)])
1295
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
1386 if __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