blinkster: comparison web/lib/django/utils/datastructures.py

equal deleted inserted replaced

-:b758351d191f
+:cc9b7e14412b
+from types import GeneratorType
+from django.utils.copycompat import deepcopy
 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.
 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):
-item_list = []
+return list(self.iteritems())
-for dict_ in self.dicts:
-item_list.extend(dict_.items())
+def keys(self):
-return item_list
+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__()
 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 = []
 for key, value in data:
 if key not in self.keyOrder:
 self.keyOrder.append(key)
 def __deepcopy__(self, memo):
-from copy import deepcopy
 return self.__class__([(key, deepcopy(value, memo))
 for key, value in self.iteritems()])
 def __setitem__(self, key, value):
+if key not in self:
+self.keyOrder.append(key)
 super(SortedDict, self).__setitem__(key, value)
-if key not in self.keyOrder:
-self.keyOrder.append(key)
 def __delitem__(self, key):
 super(SortedDict, self).__delitem__(key)
 self.keyOrder.remove(key)
 def __iter__(self):
-for k in self.keyOrder:
+return iter(self.keyOrder)
-yield k
 def pop(self, k, *args):
 result = super(SortedDict, self).pop(k, *args)
 try:
 self.keyOrder.remove(k)
 def items(self):
 return zip(self.keyOrder, self.values())
 def iteritems(self):
 for key in self.keyOrder:
-yield key, super(SortedDict, self).__getitem__(key)
+yield key, self[key]
 def keys(self):
 return self.keyOrder[:]
 def iterkeys(self):
 return iter(self.keyOrder)
 def values(self):
-return map(super(SortedDict, self).__getitem__, self.keyOrder)
+return map(self.__getitem__, self.keyOrder)
 def itervalues(self):
 for key in self.keyOrder:
-yield super(SortedDict, self).__getitem__(key)
+yield self[key]
 def update(self, dict_):
-for k, v in dict_.items():
+for k, v in dict_.iteritems():
-self.__setitem__(k, v)
+self[k] = v
 def setdefault(self, key, default):
-if key not in self.keyOrder:
+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."""
 raises KeyError if not found.
 """
 try:
 list_ = super(MultiValueDict, self).__getitem__(key)
 except KeyError:
-raise MultiValueDictKeyError, "Key %r not found in %r" % (key, self)
+raise MultiValueDictKeyError("Key %r not found in %r" % (key, self))
 try:
 return list_[-1]
 except IndexError:
 return []
 def __copy__(self):
 return self.__class__(super(MultiValueDict, self).items())
 def __deepcopy__(self, memo=None):
-import copy
+import django.utils.copycompat as copy
 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.
 """
 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 copy of this object."""
 return self.__deepcopy__()
 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)
+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"
+raise ValueError("MultiValueDict.update() takes either a MultiValueDict or dictionary")
 for key, value in kwargs.iteritems():
 self.setlistdefault(key, []).append(value)
 class DotExpandedDict(dict):
 """
 def complain(self, *wargs, **kwargs):
 if isinstance(self.warning, Exception):
 raise self.warning
 else:
-raise AttributeError, self.warning
+raise AttributeError(self.warning)
 # All list mutation functions complain.
 __delitem__  = complain
 __delslice__ = complain
 __iadd__     = complain

changeset 29	cc9b7e14412b
parent 0	0d40e90630ef