Work on multidict

Author: asvetlov

aiohttp/multidict.py

@@ -1,6 +1,6 @@
 import pprint
 from itertools import chain
-from collections import OrderedDict, abc
+from collections import abc
 
 _marker = object()
 
@@ -17,7 +17,7 @@ def __init__(self, *args, **kwargs):
         if len(args) > 1:
             raise TypeError("MultiDict takes at most 2 positional "
                             "arguments ({} given)".format(len(args) + 1))
-        self._items = OrderedDict()
+        self._items = []
         if args:
             if hasattr(args[0], 'items'):
                 args = list(args[0].items())
@@ -27,18 +27,7 @@ def __init__(self, *args, **kwargs):
         self._fill(chain(args, kwargs.items()))
 
     def _fill(self, ipairs):
-        for key, value in ipairs:
-            if key in self._items:
-                self._items[key].append(value)
-            else:
-                self._items[key] = [value]
-
-    def get(self, key, default=None):
-        """Return first value stored at key."""
-        if key in self._items and self._items[key]:
-            return self._items[key][0]
-        else:
-            return default
+        self._items.extend(ipairs)
 
     def getall(self, key, default=_marker):
         """Returns all values stored at key as a tuple.
@@ -53,8 +42,16 @@ def getall(self, key, default=_marker):
                 raise KeyError(key)
 
     def getone(self, key):
-        """Return first value stored at key."""
-        return self._items[key][0]
+        """
+        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:
+            raise KeyError('Multiple values match %r: %r' % (key, v))
+        return v[0]
 
     # extra methods #
 
@@ -66,14 +63,20 @@ def copy(self):
     # Mapping interface #
 
     def __getitem__(self, key):
-        return self._items[key][0]
+        for k, v in reversed(self._items):
+            if k == key:
+                return v
+        raise KeyError(key)
 
     def __iter__(self):
         return iter(self._items)
 
     def __len__(self):
         return len(self._items)
 
+    def keys(self, *, getall=False):
+        return _KeysView(self._items, getall=getall)
+
     def items(self, *, getall=False):
         return _ItemsView(self._items, getall=getall)
 
@@ -88,7 +91,10 @@ def __eq__(self, other):
         return dict(self.items()) == dict(other.items())
 
     def __contains__(self, key):
-        return key in self._items
+        for k, v in self._items:
+            if k == key:
+                return True
+        return False
 
     def __repr__(self):
         return '<{}>\n{}'.format(
@@ -118,20 +124,16 @@ def getall(self, key, default=_marker):
         return super().getall(key.upper(), default)
 
     def get(self, key, default=None):
-        key = key.upper()
-        if key in self._items and self._items[key]:
-            return self._items[key][0]
-        else:
-            return default
+        return self.get(key.upper(), default)
 
     def getone(self, key):
         return self._items[key.upper()][0]
 
     def __getitem__(self, key):
-        return self._items[key.upper()][0]
+        return super().__getitem__(key.upper())
 
     def __contains__(self, key):
-        return key.upper() in self._items
+        return super().__contains__(key.upper())
 
 
 class BaseMutableMultiDict(abc.MutableMapping):
@@ -148,11 +150,10 @@ def getall(self, key, default=_marker):
             return result
 
     def add(self, key, value):
-        """Adds value to a key."""
-        if key in self._items:
-            self._items[key].append(value)
-        else:
-            self._items[key] = [value]
+        """
+        Add the key and value, not overwriting any previous value.
+        """
+        self._items.append((key, value))
 
     def extend(self, *args, **kwargs):
         """Extends current MutableMultiDict with more values.
@@ -181,10 +182,21 @@ def clear(self):
     # MutableMapping interface #
 
     def __setitem__(self, key, value):
-        self._items[key] = [value]
+        try:
+            del self[key]
+        except KeyError:
+            pass
+        self._items.append((key, value))
 
     def __delitem__(self, key):
-        del self._items[key]
+        items = self._items
+        found = False
+        for i in range(len(items)-1, -1, -1):
+            if items[i][0] == key:
+                del items[i]
+                found = True
+        if not found:
+            raise KeyError(key)
 
     def pop(self, key, default=None):
         """Method not allowed."""
@@ -214,56 +226,37 @@ def add(self, key, value):
         super().add(key.upper(), value)
 
     def __setitem__(self, key, value):
-        self._items[key.upper()] = [value]
+        super().__setitem__(key.upper(), value)
 
     def __delitem__(self, key):
-        del self._items[key.upper()]
+        super().__delitem__(key.upper())
+
+
+class _KeysView(abc.ItemsView):
+
+    def __init__(self, items, *, getall=False):
+        super().__init__(items)
+        self._getall = getall
+        # TBD
 
 
 class _ItemsView(abc.ItemsView):
 
-    def __init__(self, mapping, *, getall=False):
-        super().__init__(mapping)
+    def __init__(self, items, *, getall=False):
+        super().__init__(items)
         self._getall = getall
 
     def __contains__(self, item):
-        key, value = item
-        try:
-            values = self._mapping[key]
-        except KeyError:
-            return False
-        else:
-            if self._getall:
-                return value in values
-            else:
-                return value == values[0]
+        # TBD
+        pass
 
     def __iter__(self):
-        for key, values in self._mapping.items():
-            if self._getall:
-                for value in values:
-                    yield key, value
-            else:
-                yield key, values[0]
+        pass
 
 
 class _ValuesView(abc.KeysView):
 
     def __init__(self, mapping, *, getall=False):
         super().__init__(mapping)
         self._getall = getall
-
-    def __contains__(self, value):
-        for values in self._mapping.values():
-            if self._getall and value in values:
-                return True
-            elif value == values[0]:
-                return True
-        return False
-
-    def __iter__(self):
-        for values in self._mapping.values():
-            if self._getall:
-                yield from iter(values)
-            else:
-                yield values[0]
+        # TBD