Source code for sas.sascalc.data_util.ordereddict

#!/usr/bin/env python
"""Backport from python2.7 to python <= 2.6."""

from itertools import repeat as _repeat, chain as _chain, starmap as _starmap

    from itertools import izip_longest as _zip_longest
except ImportError:

    from itertools import izip

    def _zip_longest(*args, **kwds):
        # izip_longest('ABCD', 'xy', fillvalue='-') --> Ax By C- D-
        fillvalue = kwds.get('fillvalue')
        def sentinel(counter = ([fillvalue]*(len(args)-1)).pop):
            yield counter()         # yields the fillvalue, or raises IndexError
        fillers = _repeat(fillvalue)
        iters = [_chain(it, sentinel(), fillers) for it in args]
            for tup in izip(*iters):
                yield tup
        except IndexError:

[docs]class OrderedDict(dict): def __init__(self, *args, **kwds): if len(args) > 1: raise TypeError('expected at most 1 arguments, got %d' % len(args)) if not hasattr(self, '_keys'): self._keys = [] self.update(*args, **kwds)
[docs] def clear(self): del self._keys[:] dict.clear(self)
def __setitem__(self, key, value): if key not in self: self._keys.append(key) dict.__setitem__(self, key, value) def __delitem__(self, key): dict.__delitem__(self, key) self._keys.remove(key) def __iter__(self): return iter(self._keys) def __reversed__(self): return reversed(self._keys)
[docs] def popitem(self): if not self: raise KeyError('dictionary is empty') key = self._keys.pop() value = dict.pop(self, key) return key, value
def __reduce__(self): items = [[k, self[k]] for k in self] inst_dict = vars(self).copy() inst_dict.pop('_keys', None) return (self.__class__, (items,), inst_dict)
[docs] def setdefault(self, key, default=None): try: return self[key] except KeyError: self[key] = default return default
[docs] def update(self, other=(), **kwds): if hasattr(other, "keys"): for key in other.keys(): self[key] = other[key] else: for key, value in other: self[key] = value for key, value in kwds.items(): self[key] = value
__marker = object()
[docs] def pop(self, key, default=__marker): try: value = self[key] except KeyError: if default is self.__marker: raise return default else: del self[key] return value
[docs] def keys(self): return list(self)
[docs] def values(self): return [self[key] for key in self]
[docs] def items(self): return [(key, self[key]) for key in self]
def __repr__(self): if not self: return '%s()' % (self.__class__.__name__,) return '%s(%r)' % (self.__class__.__name__, list(self.items()))
[docs] def copy(self): return self.__class__(self)
[docs] def fromkeys(cls, iterable, value=None): d = cls() for key in iterable: d[key] = value return d
def __eq__(self, other): if isinstance(other, OrderedDict): return all(p==q for p, q in _zip_longest(self.items(), other.items())) return dict.__eq__(self, other)
# End class OrderedDict