more work on multidict

Author: mind1m

aiohttp/multidict.py

@@ -23,33 +23,36 @@ def __init__(self, *args, **kwargs):
                 args = list(args[0].items())
             else:
                 args = list(args[0])
+                for arg in args:
+                    if not len(arg) == 2:
+                        raise TypeError(
+                            "MultiDict takes either dict or list of \
+                            (key, value) tuples"
+                        )
 
         self._fill(chain(args, kwargs.items()))
 
     def _fill(self, ipairs):
         self._items.extend(ipairs)
 
     def getall(self, key, default=_marker):
-        """Returns all values stored at key as a tuple.
-
-        Raises KeyError if key doesn't exist."""
-        if key in self._items:
-            return tuple(self._items[key])
-        else:
-            if default is not _marker:
-                return default
-            else:
-                raise KeyError(key)
-
-    def getone(self, key):
+        """
+        Return a list of all values matching the key (may be an empty list)
+        """
+        res = tuple([v for k, v in self._items if k == key])
+        if res:
+            return res
+        if not res and default != _marker:
+            return default
+        raise KeyError('Key not found: %r' % key)
+
+    def getone(self, key, default=_marker):
         """
         Get one value matching the key, raising a KeyError if multiple
         values were found.
         """
-        v = self.getall(key)
-        if not v:
-            raise KeyError('Key not found: %r' % key)
-        if len(v) > 1:
+        v = self.getall(key, default=_marker)
+        if len(v) > 1 and v != default:
             raise KeyError('Multiple values match %r: %r' % (key, v))
         return v[0]
 
@@ -63,7 +66,7 @@ def copy(self):
     # Mapping interface #
 
     def __getitem__(self, key):
-        for k, v in reversed(self._items):
+        for k, v in self._items:
             if k == key:
                 return v
         raise KeyError(key)
@@ -74,14 +77,14 @@ def __iter__(self):
     def __len__(self):
         return len(self._items)
 
-    def keys(self, *, getall=False):
-        return _KeysView(self._items, getall=getall)
+    def keys(self):
+        return _KeysView(self._items)
 
-    def items(self, *, getall=False):
-        return _ItemsView(self._items, getall=getall)
+    def items(self):
+        return _ItemsView(self._items)
 
-    def values(self, *, getall=False):
-        return _ValuesView(self._items, getall=getall)
+    def values(self):
+        return _ValuesView(self._items)
 
     def __eq__(self, other):
         if not isinstance(other, abc.Mapping):
@@ -99,7 +102,7 @@ def __contains__(self, key):
     def __repr__(self):
         return '<{}>\n{}'.format(
             self.__class__.__name__, pprint.pformat(
-                list(self.items(getall=True))))
+                list(self.items())))
 
 
 class CaseInsensitiveMultiDict(MultiDict):
@@ -114,20 +117,14 @@ def _from_uppercase_multidict(cls, dct):
 
     def _fill(self, ipairs):
         for key, value in ipairs:
-            key = key.upper()
-            if key in self._items:
-                self._items[key].append(value)
-            else:
-                self._items[key] = [value]
+            uppkey = key.upper()
+            self._items.append((uppkey, value))
 
     def getall(self, key, default=_marker):
         return super().getall(key.upper(), default)
 
-    def get(self, key, default=None):
-        return self.get(key.upper(), default)
-
-    def getone(self, key):
-        return self._items[key.upper()][0]
+    def getone(self, key, default=_marker):
+        return super().getone(key.upper(), default)
 
     def __getitem__(self, key):
         return super().__getitem__(key.upper())
@@ -136,18 +133,7 @@ def __contains__(self, key):
         return super().__contains__(key.upper())
 
 
-class BaseMutableMultiDict(abc.MutableMapping):
-
-    def getall(self, key, default=_marker):
-        """Returns all values stored at key as list.
-
-        Raises KeyError if key doesn't exist.
-        """
-        result = super().getall(key, default)
-        if result is not default:
-            return list(result)
-        else:
-            return result
+class MutableMultiDictMixin(abc.MutableMapping):
 
     def add(self, key, value):
         """
@@ -211,17 +197,14 @@ def update(self, *args, **kw):
         raise NotImplementedError("Use extend method instead")
 
 
-class MutableMultiDict(BaseMutableMultiDict, MultiDict):
+class MutableMultiDict(MutableMultiDictMixin, MultiDict):
     """An ordered dictionary that can have multiple values for each key."""
 
 
 class CaseInsensitiveMutableMultiDict(
-        BaseMutableMultiDict, CaseInsensitiveMultiDict):
+        MutableMultiDictMixin, CaseInsensitiveMultiDict):
     """An ordered dictionary that can have multiple values for each key."""
 
-    def getall(self, key, default=_marker):
-        return super().getall(key.upper(), default)
-
     def add(self, key, value):
         super().add(key.upper(), value)
 
@@ -232,31 +215,34 @@ def __delitem__(self, key):
         super().__delitem__(key.upper())
 
 
-class _KeysView(abc.ItemsView):
+class _ItemsView(abc.ItemsView):
 
-    def __init__(self, items, *, getall=False):
-        super().__init__(items)
-        self._getall = getall
-        # TBD
+    def __contains__(self, item):
+        assert isinstance(item, tuple) or isinstance(item, list)
+        assert len(item) == 2
+        return item in self._mapping
 
+    def __iter__(self):
+        yield from self._mapping
 
-class _ItemsView(abc.ItemsView):
 
-    def __init__(self, items, *, getall=False):
-        super().__init__(items)
-        self._getall = getall
+class _ValuesView(abc.ValuesView):
 
-    def __contains__(self, item):
-        # TBD
-        pass
+    def __contains__(self, value):
+        values = [item[1] for item in self._mapping]
+        return value in values
 
     def __iter__(self):
-        pass
+        values = [item[1] for item in self._mapping]
+        yield from values
 
 
-class _ValuesView(abc.KeysView):
+class _KeysView(abc.KeysView):
 
-    def __init__(self, mapping, *, getall=False):
-        super().__init__(mapping)
-        self._getall = getall
-        # TBD
+    def __contains__(self, key):
+        keys = set([item[0] for item in self._mapping])
+        return key in keys
+
+    def __iter__(self):
+        keys = set([item[0] for item in self._mapping])
+        yield from keys