489 lines
15 KiB
Python
489 lines
15 KiB
Python
import copy
|
|
import warnings
|
|
from types import GeneratorType
|
|
|
|
|
|
class MergeDict(object):
|
|
"""
|
|
A simple class for creating new "virtual" dictionaries that actually look
|
|
up values in more than one dictionary, passed in the constructor.
|
|
|
|
If a key appears in more than one of the given dictionaries, only the
|
|
first occurrence will be used.
|
|
"""
|
|
def __init__(self, *dicts):
|
|
self.dicts = dicts
|
|
|
|
def __getitem__(self, key):
|
|
for dict_ in self.dicts:
|
|
try:
|
|
return dict_[key]
|
|
except KeyError:
|
|
pass
|
|
raise KeyError
|
|
|
|
def __copy__(self):
|
|
return self.__class__(*self.dicts)
|
|
|
|
def get(self, key, default=None):
|
|
try:
|
|
return self[key]
|
|
except KeyError:
|
|
return default
|
|
|
|
def getlist(self, key):
|
|
for dict_ in self.dicts:
|
|
if key in dict_.keys():
|
|
return dict_.getlist(key)
|
|
return []
|
|
|
|
def iteritems(self):
|
|
seen = set()
|
|
for dict_ in self.dicts:
|
|
for item in dict_.iteritems():
|
|
k, v = item
|
|
if k in seen:
|
|
continue
|
|
seen.add(k)
|
|
yield item
|
|
|
|
def iterkeys(self):
|
|
for k, v in self.iteritems():
|
|
yield k
|
|
|
|
def itervalues(self):
|
|
for k, v in self.iteritems():
|
|
yield v
|
|
|
|
def items(self):
|
|
return list(self.iteritems())
|
|
|
|
def keys(self):
|
|
return list(self.iterkeys())
|
|
|
|
def values(self):
|
|
return list(self.itervalues())
|
|
|
|
def has_key(self, key):
|
|
for dict_ in self.dicts:
|
|
if key in dict_:
|
|
return True
|
|
return False
|
|
|
|
__contains__ = has_key
|
|
__iter__ = iterkeys
|
|
|
|
def copy(self):
|
|
"""Returns a copy of this object."""
|
|
return self.__copy__()
|
|
|
|
def __str__(self):
|
|
'''
|
|
Returns something like
|
|
|
|
"{'key1': 'val1', 'key2': 'val2', 'key3': 'val3'}"
|
|
|
|
instead of the generic "<object meta-data>" inherited from object.
|
|
'''
|
|
return str(dict(self.items()))
|
|
|
|
def __repr__(self):
|
|
'''
|
|
Returns something like
|
|
|
|
MergeDict({'key1': 'val1', 'key2': 'val2'}, {'key3': 'val3'})
|
|
|
|
instead of generic "<object meta-data>" inherited from object.
|
|
'''
|
|
dictreprs = ', '.join(repr(d) for d in self.dicts)
|
|
return '%s(%s)' % (self.__class__.__name__, dictreprs)
|
|
|
|
class SortedDict(dict):
|
|
"""
|
|
A dictionary that keeps its keys in the order in which they're inserted.
|
|
"""
|
|
def __new__(cls, *args, **kwargs):
|
|
instance = super(SortedDict, cls).__new__(cls, *args, **kwargs)
|
|
instance.keyOrder = []
|
|
return instance
|
|
|
|
def __init__(self, data=None):
|
|
if data is None:
|
|
data = {}
|
|
elif isinstance(data, GeneratorType):
|
|
# Unfortunately we need to be able to read a generator twice. Once
|
|
# to get the data into self with our super().__init__ call and a
|
|
# second time to setup keyOrder correctly
|
|
data = list(data)
|
|
super(SortedDict, self).__init__(data)
|
|
if isinstance(data, dict):
|
|
self.keyOrder = data.keys()
|
|
else:
|
|
self.keyOrder = []
|
|
seen = set()
|
|
for key, value in data:
|
|
if key not in seen:
|
|
self.keyOrder.append(key)
|
|
seen.add(key)
|
|
|
|
def __deepcopy__(self, memo):
|
|
return self.__class__([(key, copy.deepcopy(value, memo))
|
|
for key, value in self.iteritems()])
|
|
|
|
def __copy__(self):
|
|
# The Python's default copy implementation will alter the state
|
|
# of self. The reason for this seems complex but is likely related to
|
|
# subclassing dict.
|
|
return self.copy()
|
|
|
|
def __setitem__(self, key, value):
|
|
if key not in self:
|
|
self.keyOrder.append(key)
|
|
super(SortedDict, self).__setitem__(key, value)
|
|
|
|
def __delitem__(self, key):
|
|
super(SortedDict, self).__delitem__(key)
|
|
self.keyOrder.remove(key)
|
|
|
|
def __iter__(self):
|
|
return iter(self.keyOrder)
|
|
|
|
def pop(self, k, *args):
|
|
result = super(SortedDict, self).pop(k, *args)
|
|
try:
|
|
self.keyOrder.remove(k)
|
|
except ValueError:
|
|
# Key wasn't in the dictionary in the first place. No problem.
|
|
pass
|
|
return result
|
|
|
|
def popitem(self):
|
|
result = super(SortedDict, self).popitem()
|
|
self.keyOrder.remove(result[0])
|
|
return result
|
|
|
|
def items(self):
|
|
return zip(self.keyOrder, self.values())
|
|
|
|
def iteritems(self):
|
|
for key in self.keyOrder:
|
|
yield key, self[key]
|
|
|
|
def keys(self):
|
|
return self.keyOrder[:]
|
|
|
|
def iterkeys(self):
|
|
return iter(self.keyOrder)
|
|
|
|
def values(self):
|
|
return map(self.__getitem__, self.keyOrder)
|
|
|
|
def itervalues(self):
|
|
for key in self.keyOrder:
|
|
yield self[key]
|
|
|
|
def update(self, dict_):
|
|
for k, v in dict_.iteritems():
|
|
self[k] = v
|
|
|
|
def setdefault(self, key, default):
|
|
if key not in self:
|
|
self.keyOrder.append(key)
|
|
return super(SortedDict, self).setdefault(key, default)
|
|
|
|
def value_for_index(self, index):
|
|
"""Returns the value of the item at the given zero-based index."""
|
|
# This, and insert() are deprecated because they cannot be implemented
|
|
# using collections.OrderedDict (Python 2.7 and up), which we'll
|
|
# eventually switch to
|
|
warnings.warn(PendingDeprecationWarning,
|
|
"SortedDict.value_for_index is deprecated", stacklevel=2)
|
|
return self[self.keyOrder[index]]
|
|
|
|
def insert(self, index, key, value):
|
|
"""Inserts the key, value pair before the item with the given index."""
|
|
warnings.warn(PendingDeprecationWarning,
|
|
"SortedDict.insert is deprecated", stacklevel=2)
|
|
if key in self.keyOrder:
|
|
n = self.keyOrder.index(key)
|
|
del self.keyOrder[n]
|
|
if n < index:
|
|
index -= 1
|
|
self.keyOrder.insert(index, key)
|
|
super(SortedDict, self).__setitem__(key, value)
|
|
|
|
def copy(self):
|
|
"""Returns a copy of this object."""
|
|
# This way of initializing the copy means it works for subclasses, too.
|
|
return self.__class__(self)
|
|
|
|
def __repr__(self):
|
|
"""
|
|
Replaces the normal dict.__repr__ with a version that returns the keys
|
|
in their sorted order.
|
|
"""
|
|
return '{%s}' % ', '.join(['%r: %r' % (k, v) for k, v in self.items()])
|
|
|
|
def clear(self):
|
|
super(SortedDict, self).clear()
|
|
self.keyOrder = []
|
|
|
|
class MultiValueDictKeyError(KeyError):
|
|
pass
|
|
|
|
class MultiValueDict(dict):
|
|
"""
|
|
A subclass of dictionary customized to handle multiple values for the
|
|
same key.
|
|
|
|
>>> d = MultiValueDict({'name': ['Adrian', 'Simon'], 'position': ['Developer']})
|
|
>>> d['name']
|
|
'Simon'
|
|
>>> d.getlist('name')
|
|
['Adrian', 'Simon']
|
|
>>> d.getlist('doesnotexist')
|
|
[]
|
|
>>> d.getlist('doesnotexist', ['Adrian', 'Simon'])
|
|
['Adrian', 'Simon']
|
|
>>> d.get('lastname', 'nonexistent')
|
|
'nonexistent'
|
|
>>> d.setlist('lastname', ['Holovaty', 'Willison'])
|
|
|
|
This class exists to solve the irritating problem raised by cgi.parse_qs,
|
|
which returns a list for every key, even though most Web forms submit
|
|
single name-value pairs.
|
|
"""
|
|
def __init__(self, key_to_list_mapping=()):
|
|
super(MultiValueDict, self).__init__(key_to_list_mapping)
|
|
|
|
def __repr__(self):
|
|
return "<%s: %s>" % (self.__class__.__name__,
|
|
super(MultiValueDict, self).__repr__())
|
|
|
|
def __getitem__(self, key):
|
|
"""
|
|
Returns the last data value for this key, or [] if it's an empty list;
|
|
raises KeyError if not found.
|
|
"""
|
|
try:
|
|
list_ = super(MultiValueDict, self).__getitem__(key)
|
|
except KeyError:
|
|
raise MultiValueDictKeyError("Key %r not found in %r" % (key, self))
|
|
try:
|
|
return list_[-1]
|
|
except IndexError:
|
|
return []
|
|
|
|
def __setitem__(self, key, value):
|
|
super(MultiValueDict, self).__setitem__(key, [value])
|
|
|
|
def __copy__(self):
|
|
return self.__class__([
|
|
(k, v[:])
|
|
for k, v in self.lists()
|
|
])
|
|
|
|
def __deepcopy__(self, memo=None):
|
|
if memo is None:
|
|
memo = {}
|
|
result = self.__class__()
|
|
memo[id(self)] = result
|
|
for key, value in dict.items(self):
|
|
dict.__setitem__(result, copy.deepcopy(key, memo),
|
|
copy.deepcopy(value, memo))
|
|
return result
|
|
|
|
def __getstate__(self):
|
|
obj_dict = self.__dict__.copy()
|
|
obj_dict['_data'] = dict([(k, self.getlist(k)) for k in self])
|
|
return obj_dict
|
|
|
|
def __setstate__(self, obj_dict):
|
|
data = obj_dict.pop('_data', {})
|
|
for k, v in data.items():
|
|
self.setlist(k, v)
|
|
self.__dict__.update(obj_dict)
|
|
|
|
def get(self, key, default=None):
|
|
"""
|
|
Returns the last data value for the passed key. If key doesn't exist
|
|
or value is an empty list, then default is returned.
|
|
"""
|
|
try:
|
|
val = self[key]
|
|
except KeyError:
|
|
return default
|
|
if val == []:
|
|
return default
|
|
return val
|
|
|
|
def getlist(self, key, default=None):
|
|
"""
|
|
Returns the list of values for the passed key. If key doesn't exist,
|
|
then a default value is returned.
|
|
"""
|
|
try:
|
|
return super(MultiValueDict, self).__getitem__(key)
|
|
except KeyError:
|
|
if default is None:
|
|
return []
|
|
return default
|
|
|
|
def setlist(self, key, list_):
|
|
super(MultiValueDict, self).__setitem__(key, list_)
|
|
|
|
def setdefault(self, key, default=None):
|
|
if key not in self:
|
|
self[key] = default
|
|
return default
|
|
return self[key]
|
|
|
|
def setlistdefault(self, key, default_list=None):
|
|
if key not in self:
|
|
if default_list is None:
|
|
default_list = []
|
|
self.setlist(key, default_list)
|
|
return self.getlist(key)
|
|
|
|
def appendlist(self, key, value):
|
|
"""Appends an item to the internal list associated with key."""
|
|
self.setlistdefault(key).append(value)
|
|
|
|
def items(self):
|
|
"""
|
|
Returns a list of (key, value) pairs, where value is the last item in
|
|
the list associated with the key.
|
|
"""
|
|
return [(key, self[key]) for key in self.keys()]
|
|
|
|
def iteritems(self):
|
|
"""
|
|
Yields (key, value) pairs, where value is the last item in the list
|
|
associated with the key.
|
|
"""
|
|
for key in self.keys():
|
|
yield (key, self[key])
|
|
|
|
def lists(self):
|
|
"""Returns a list of (key, list) pairs."""
|
|
return super(MultiValueDict, self).items()
|
|
|
|
def iterlists(self):
|
|
"""Yields (key, list) pairs."""
|
|
return super(MultiValueDict, self).iteritems()
|
|
|
|
def values(self):
|
|
"""Returns a list of the last value on every key list."""
|
|
return [self[key] for key in self.keys()]
|
|
|
|
def itervalues(self):
|
|
"""Yield the last value on every key list."""
|
|
for key in self.iterkeys():
|
|
yield self[key]
|
|
|
|
def copy(self):
|
|
"""Returns a shallow copy of this object."""
|
|
return copy.copy(self)
|
|
|
|
def update(self, *args, **kwargs):
|
|
"""
|
|
update() extends rather than replaces existing key lists.
|
|
Also accepts keyword args.
|
|
"""
|
|
if len(args) > 1:
|
|
raise TypeError("update expected at most 1 arguments, got %d" % len(args))
|
|
if args:
|
|
other_dict = args[0]
|
|
if isinstance(other_dict, MultiValueDict):
|
|
for key, value_list in other_dict.lists():
|
|
self.setlistdefault(key).extend(value_list)
|
|
else:
|
|
try:
|
|
for key, value in other_dict.items():
|
|
self.setlistdefault(key).append(value)
|
|
except TypeError:
|
|
raise ValueError("MultiValueDict.update() takes either a MultiValueDict or dictionary")
|
|
for key, value in kwargs.iteritems():
|
|
self.setlistdefault(key).append(value)
|
|
|
|
def dict(self):
|
|
"""
|
|
Returns current object as a dict with singular values.
|
|
"""
|
|
return dict((key, self[key]) for key in self)
|
|
|
|
|
|
class ImmutableList(tuple):
|
|
"""
|
|
A tuple-like object that raises useful errors when it is asked to mutate.
|
|
|
|
Example::
|
|
|
|
>>> a = ImmutableList(range(5), warning="You cannot mutate this.")
|
|
>>> a[3] = '4'
|
|
Traceback (most recent call last):
|
|
...
|
|
AttributeError: You cannot mutate this.
|
|
"""
|
|
|
|
def __new__(cls, *args, **kwargs):
|
|
if 'warning' in kwargs:
|
|
warning = kwargs['warning']
|
|
del kwargs['warning']
|
|
else:
|
|
warning = 'ImmutableList object is immutable.'
|
|
self = tuple.__new__(cls, *args, **kwargs)
|
|
self.warning = warning
|
|
return self
|
|
|
|
def complain(self, *wargs, **kwargs):
|
|
if isinstance(self.warning, Exception):
|
|
raise self.warning
|
|
else:
|
|
raise AttributeError(self.warning)
|
|
|
|
# All list mutation functions complain.
|
|
__delitem__ = complain
|
|
__delslice__ = complain
|
|
__iadd__ = complain
|
|
__imul__ = complain
|
|
__setitem__ = complain
|
|
__setslice__ = complain
|
|
append = complain
|
|
extend = complain
|
|
insert = complain
|
|
pop = complain
|
|
remove = complain
|
|
sort = complain
|
|
reverse = complain
|
|
|
|
class DictWrapper(dict):
|
|
"""
|
|
Wraps accesses to a dictionary so that certain values (those starting with
|
|
the specified prefix) are passed through a function before being returned.
|
|
The prefix is removed before looking up the real value.
|
|
|
|
Used by the SQL construction code to ensure that values are correctly
|
|
quoted before being used.
|
|
"""
|
|
def __init__(self, data, func, prefix):
|
|
super(DictWrapper, self).__init__(data)
|
|
self.func = func
|
|
self.prefix = prefix
|
|
|
|
def __getitem__(self, key):
|
|
"""
|
|
Retrieves the real value after stripping the prefix string (if
|
|
present). If the prefix is present, pass the value through self.func
|
|
before returning, otherwise return the raw value.
|
|
"""
|
|
if key.startswith(self.prefix):
|
|
use_func = True
|
|
key = key[len(self.prefix):]
|
|
else:
|
|
use_func = False
|
|
value = super(DictWrapper, self).__getitem__(key)
|
|
if use_func:
|
|
return self.func(value)
|
|
return value
|