Merge pull request #227 from KeepSafe/multidict_refactoring

Multidict refactoring

Author: asvetlov

CHANGES.txt

@@ -22,6 +22,11 @@ CHANGES
 
 - multidict.getall() returns `list`, not `tuple`.
 
+- Backward imcompatible change: now there are two mutable multidicts
+  (`MultiDict`, `CIMultiDict`) and two immutable multidict proxies
+  (`MultiDictProxy` and `CIMultiDictProxy`). Previous edition of
+  multidicts was not a part of public API though.
+
 
 0.13.1 (12-31-2014)
 --------------------

aiohttp/_multidict.pyx

@@ -26,49 +26,14 @@ class upstr(str):
         return self
 
 
-cdef class MultiDict:
-    """Read-only ordered dictionary that can have multiple values for each key.
-
-    This type of MultiDict must be used for request headers and query args.
-    """
+cdef class _Base:
 
     cdef list _items
     cdef object _upstr
 
-    def __init__(self, *args, **kwargs):
+    def __cinit__(self):
         self._upstr = upstr
-        self._items = []
-
-        self._extend(args, kwargs, self.__class__.__name__)
-
-    cdef _extend(self, tuple args, dict kwargs, name):
-        cdef tuple item
-
-        if len(args) > 1:
-            raise TypeError("{} takes at most 1 positional argument"
-                            " ({} given)".format(name, len(args)))
-
-        if args:
-            if hasattr(args[0], 'items'):
-                for item in args[0].items():
-                    self._add(item)
-            else:
-                for arg in args[0]:
-                    if not len(arg) == 2:
-                        raise TypeError(
-                            "{} takes either dict or list of (key, value) "
-                            "tuples".format(name))
-                    if not isinstance(arg, tuple):
-                        item = tuple(arg)
-                    else:
-                        item = arg
-                    self._add(item)
-
-        for item in kwargs.items():
-            self._add(item)
 
-    cdef _add(self, tuple item):
-        self._items.append(item)
 
     def getall(self, key, default=_marker):
         """
@@ -100,13 +65,6 @@ cdef class MultiDict:
             return default
         raise KeyError('Key not found: %r' % key)
 
-    # extra methods #
-
-    def copy(self):
-        """Returns a copy itself."""
-        cls = self.__class__
-        return cls(self._items)
-
     # Mapping interface #
 
     def __getitem__(self, key):
@@ -125,16 +83,6 @@ cdef class MultiDict:
                 return True
         return False
 
-    cdef _delitem(self, key, int raise_key_error):
-        cdef int found
-        found = False
-        for i in range(len(self._items) - 1, -1, -1):
-            if self._items[i][0] == key:
-                del self._items[i]
-                found = True
-        if not found and raise_key_error:
-            raise KeyError(key)
-
     def __iter__(self):
         return iter(self.keys())
 
@@ -159,27 +107,56 @@ cdef class MultiDict:
     cdef _ValuesView _values_view(self, getall):
         return _ValuesView.__new__(_ValuesView, self._items, getall)
 
+    def __repr__(self):
+        body = ', '.join("'{}': {!r}".format(k, v) for k, v in self.items())
+        return '<{} {{{}}}>'.format(self.__class__.__name__, body)
+
+
+
+
+
+cdef class MultiDictProxy(_Base):
+
+    def __init__(self, arg):
+        cdef MultiDict mdict
+        if not isinstance(arg, MultiDict):
+            raise TypeError(
+                'MultiDictProxy requires MultiDict instance, not {}'.format(
+                    type(arg)))
+
+        mdict = arg
+        self._items = mdict._items
+
+    def copy(self):
+        return MultiDict(self._items)
+
     def __richcmp__(self, other, op):
-        cdef MultiDict typed_self = self
-        cdef MultiDict typed_other
+        cdef MultiDictProxy typed_self = self
+        cdef MultiDictProxy typed_other
         cdef tuple item
         if op == 2:
-            if not isinstance(other, abc.Mapping):
-                return NotImplemented
-            if isinstance(other, MultiDict):
+            if isinstance(other, MultiDictProxy):
                 typed_other = other
                 return typed_self._items == typed_other._items
+            elif isinstance(other, MultiDict):
+                typed_other = other
+                return typed_self._items == typed_other._items
+            elif not isinstance(other, abc.Mapping):
+                return NotImplemented
             for item in typed_self._items:
                 nv = other.get(item[0], _marker)
                 if item[1] != nv:
                     return False
             return True
         elif op != 2:
-            if not isinstance(other, abc.Mapping):
-                return NotImplemented
-            if isinstance(other, MultiDict):
+            if isinstance(other, MultiDictProxy):
                 typed_other = other
                 return typed_self._items != typed_other._items
+            elif isinstance(other, MultiDict):
+                typed_other = other
+                return typed_self._items == typed_other._items
+            elif not isinstance(other, abc.Mapping):
+                return NotImplemented
             for item in typed_self._items:
                 nv = other.get(item[0], _marker)
                 if item[1] == nv:
@@ -188,32 +165,29 @@ cdef class MultiDict:
         else:
             return NotImplemented
 
-    def __repr__(self):
-        body = ', '.join("'{}': {!r}".format(k, v) for k, v in self.items())
-        return '<{} {{{}}}>'.format(self.__class__.__name__, body)
 
+abc.Mapping.register(MultiDictProxy)
 
-abc.Mapping.register(MultiDict)
 
+cdef class CIMultiDictProxy(MultiDictProxy):
 
-cdef class CIMultiDict(MultiDict):
-    """Case insensitive multi dict."""
+    def __init__(self, arg):
+        cdef CIMultiDict mdict
+        if not isinstance(arg, CIMultiDict):
+            raise TypeError(
+                'CIMultiDictProxy requires CIMultiDict instance, not {}'.format(
+                    type(arg)))
 
-    @classmethod
-    def _from_uppercase_multidict(cls, MultiDict dct):
-        # NB: doesn't check for uppercase keys!
-        cdef CIMultiDict ret
-        ret = cls.__new__(cls)
-        ret._items = dct._items
-        return ret
+        mdict = arg
+        self._items = mdict._items
 
     cdef _upper(self, s):
         if type(s) is self._upstr:
             return s
         return s.upper()
 
-    cdef _add(self, tuple item):
-        self._items.append((self._upper(item[0]), item[1]))
+    def copy(self):
+        return CIMultiDict(self._items)
 
     def getall(self, key, default=_marker):
         return self._getall(self._upper(key), default)
@@ -231,28 +205,67 @@ cdef class CIMultiDict(MultiDict):
         return self._contains(self._upper(key))
 
 
-abc.Mapping.register(CIMultiDict)
+abc.Mapping.register(CIMultiDictProxy)
 
 
-cdef class MutableMultiDict(MultiDict):
+cdef class MultiDict(_Base):
     """An ordered dictionary that can have multiple values for each key."""
 
+    def __init__(self, *args, **kwargs):
+        self._items = []
+
+        self._extend(args, kwargs, self.__class__.__name__)
+
+    cdef _extend(self, tuple args, dict kwargs, name):
+        cdef tuple item
+
+        if len(args) > 1:
+            raise TypeError("{} takes at most 1 positional argument"
+                            " ({} given)".format(name, len(args)))
+
+        if args:
+            if hasattr(args[0], 'items'):
+                for item in args[0].items():
+                    self._add(item)
+            else:
+                for arg in args[0]:
+                    if not len(arg) == 2:
+                        raise TypeError(
+                            "{} takes either dict or list of (key, value) "
+                            "tuples".format(name))
+                    if not isinstance(arg, tuple):
+                        item = tuple(arg)
+                    else:
+                        item = arg
+                    self._add(item)
+
+        for item in kwargs.items():
+            self._add(item)
+
+    cdef _add(self, tuple item):
+        self._items.append(item)
+
     def add(self, key, value):
         """
         Add the key and value, not overwriting any previous value.
         """
         self._add((key, value))
 
+    def copy(self):
+        """Returns a copy itself."""
+        cls = self.__class__
+        return cls(self._items)
+
     def extend(self, *args, **kwargs):
-        """Extends current MutableMultiDict with more values.
+        """Extends current MultiDict with more values.
 
         This method must be used instead of update.
         """
         self._extend(args, kwargs, "extend")
 
     def clear(self):
-        """Remove all items from MutableMultiDict"""
-        self._items = []
+        """Remove all items from MultiDict"""
+        self._items.clear()
 
     # MutableMapping interface #
 
@@ -263,6 +276,16 @@ cdef class MutableMultiDict(MultiDict):
     def __delitem__(self, key):
         self._delitem(key, True)
 
+    cdef _delitem(self, key, int raise_key_error):
+        cdef int found
+        found = False
+        for i in range(len(self._items) - 1, -1, -1):
+            if self._items[i][0] == key:
+                del self._items[i]
+                found = True
+        if not found and raise_key_error:
+            raise KeyError(key)
+
     def setdefault(self, key, default=None):
         for k, v in self._items:
             if k == key:
@@ -282,28 +305,81 @@ cdef class MutableMultiDict(MultiDict):
         """Method not allowed."""
         raise NotImplementedError("Use extend method instead")
 
+    def __richcmp__(self, other, op):
+        cdef MultiDict typed_self = self
+        cdef MultiDict typed_other
+        cdef tuple item
+        if op == 2:
+            if isinstance(other, MultiDict):
+                typed_other = other
+                return typed_self._items == typed_other._items
+            elif not isinstance(other, abc.Mapping):
+                return NotImplemented
+            for item in typed_self._items:
+                nv = other.get(item[0], _marker)
+                if item[1] != nv:
+                    return False
+            return True
+        elif op != 2:
+            if isinstance(other, MultiDict):
+                typed_other = other
+                return typed_self._items == typed_other._items
+            elif not isinstance(other, abc.Mapping):
+                return NotImplemented
+            for item in typed_self._items:
+                nv = other.get(item[0], _marker)
+                if item[1] == nv:
+                    return True
+            return False
+        else:
+            return NotImplemented
+
+
 
-abc.MutableMapping.register(MutableMultiDict)
+abc.MutableMapping.register(MultiDict)
 
 
-cdef class CIMutableMultiDict(CIMultiDict):
+cdef class CIMultiDict(MultiDict):
     """An ordered dictionary that can have multiple values for each key."""
 
+    cdef _add(self, tuple item):
+        self._items.append((self._upper(item[0]), item[1]))
+
+    cdef _upper(self, s):
+        if type(s) is self._upstr:
+            return s
+        return s.upper()
+
+    def getall(self, key, default=_marker):
+        return self._getall(self._upper(key), default)
+
+    def getone(self, key, default=_marker):
+        return self._getone(self._upper(key), default)
+
+    def get(self, key, default=None):
+        return self._getone(self._upper(key), default)
+
+    def __getitem__(self, key):
+        return self._getone(self._upper(key), _marker)
+
+    def __contains__(self, key):
+        return self._contains(self._upper(key))
+
     def add(self, key, value):
         """
         Add the key and value, not overwriting any previous value.
         """
         self._add((key, value))
 
     def extend(self, *args, **kwargs):
-        """Extends current MutableMultiDict with more values.
+        """Extends current MultiDict with more values.
 
         This method must be used instead of update.
         """
         self._extend(args, kwargs, "extend")
 
     def clear(self):
-        """Remove all items from MutableMultiDict"""
+        """Remove all items from MultiDict"""
         self._items = []
 
     # MutableMapping interface #
@@ -337,7 +413,7 @@ cdef class CIMutableMultiDict(CIMultiDict):
         raise NotImplementedError("Use extend method instead")
 
 
-abc.MutableMapping.register(CIMutableMultiDict)
+abc.MutableMapping.register(CIMultiDict)
 
 
 cdef class _ViewBase: