fix for python3.4

Author: nxexox

rest_framework/serializers/fields.py

@@ -3,7 +3,10 @@
 
 """
 import re
-import typing
+try:
+    from typing import Mapping
+except ImportError:
+    from collections import Mapping
 import datetime
 import json
 
@@ -48,7 +51,7 @@ def get_attribute(obj, attr_name):
 
     """
     # Search attribute.
-    if isinstance(obj, typing.Mapping):
+    if isinstance(obj, Mapping):
         attr = obj[attr_name]
     else:
         attr = getattr(obj, attr_name)
@@ -725,7 +728,7 @@ def to_internal_value(self, data):
         if html.is_html_input(data):
             data = html.parse_html_list(data)
 
-        if any((isinstance(data, type('')), isinstance(data, typing.Mapping), not hasattr(data, '__iter__'))):
+        if any((isinstance(data, type('')), isinstance(data, Mapping), not hasattr(data, '__iter__'))):
             self.fail('not_a_list', input_type=type(data).__name__)
 
         if not self.allow_empty and len(data) == 0:

rest_framework/serializers/serializers.py

@@ -4,7 +4,11 @@
 """
 import copy
 import inspect
-from typing import Mapping
+try:
+    from typing import Mapping
+except ImportError:
+    from collections import Mapping
+
 from collections import OrderedDict
 
 import six

rest_framework/tests/test_serializers.py

@@ -5,7 +5,10 @@
 
 """
 # import collections
-import typing
+try:
+    from typing import Mapping
+except ImportError:
+    from collections import Mapping
 from unittest import TestCase
 
 import six
@@ -312,7 +315,7 @@ def __create_object(self, data):
 
         """
         return type('object', (object,), {
-            key: self.__create_object(val) if isinstance(val, typing.Mapping) else val
+            key: self.__create_object(val) if isinstance(val, Mapping) else val
             for key, val in six.iteritems(data)
         })
 
@@ -359,10 +362,10 @@ def test_data_serializer(self):
         # First we feed him empty data.
         ser = self.serializer_class(data=self.__create_params(fullness='empty'))
         assert ser.is_valid() is False, '`.is_valid()` must return False.'
-        assert isinstance(ser.errors, typing.Mapping), \
+        assert isinstance(ser.errors, Mapping), \
             '`.errors` must be dict. Reality: {}.'.format(type(ser.errors))
         assert len(ser.errors) > 0, '`.errors` must contain errors.'
-        assert isinstance(ser.validated_data, typing.Mapping), \
+        assert isinstance(ser.validated_data, Mapping), \
             '`.validated_data` must be dict. Reality: {}.'.format(type(ser.validated_data))
         assert len(ser.validated_data) == 0, '`.validated_data` must be empty. Reality: {},'.format(ser.validated_data)
 
@@ -377,10 +380,10 @@ def test_data_serializer(self):
         # Now we feed the data partially.
         ser = self.serializer_class(data=self.__create_params(fullness='middle'))
         assert ser.is_valid() is False, '`.is_valid()` must return False.'
-        assert isinstance(ser.errors, typing.Mapping), \
+        assert isinstance(ser.errors, Mapping), \
             '`.errors` must be dict. Reality: {}.'.format(type(ser.errors))
         assert len(ser.errors) > 0, '`.errors` must contain errors.'
-        assert isinstance(ser.validated_data, typing.Mapping), \
+        assert isinstance(ser.validated_data, Mapping), \
             '`.validated_data` must be dict. Reality: {}.'.format(type(ser.validated_data))
         assert len(ser.validated_data) == 0, '`.validated_data` must be empty. Reality: {}.'.format(ser.validated_data)
 
@@ -389,10 +392,10 @@ def test_data_serializer(self):
         ser = self.serializer_class(data=data)
         # Check logic.
         assert ser.is_valid() is True, '`.is_valid()` must return True.'
-        assert isinstance(ser.errors, typing.Mapping), \
+        assert isinstance(ser.errors, Mapping), \
             '`.errors` must be dict. Reality: {}.'.format(type(ser.errors))
         assert len(ser.errors) == 0, '`.errors` must be empty. Reality: {}.'.format(ser.errors)
-        assert isinstance(ser.validated_data, typing.Mapping), \
+        assert isinstance(ser.validated_data, Mapping), \
             '`.validated_data` must be dict. Reality: {}.'.format(ser.validated_data)
         assert len(ser.validated_data) > 0, '`.validated_data` must contain data.'
         # We check that all data is returned correctly.
@@ -410,12 +413,12 @@ def test_instance_object_serializer(self):
         """
         # First we feed him an empty object.
         ser = self.serializer_class(instance=self.__create_object(self.__create_params(fullness='empty')))
-        assert isinstance(ser.data, typing.Mapping), '`.data` must be dict. Reality: {}'.format(type(ser.data))
+        assert isinstance(ser.data, Mapping), '`.data` must be dict. Reality: {}'.format(type(ser.data))
 
         # Now we feed the data partially.
         data = self.__create_params(fullness='middle')
         ser = self.serializer_class(instance=self.__create_object(data))
-        assert isinstance(ser.data, typing.Mapping), '`.data` must be dict. Reality: {}.'.format(type(ser.data))
+        assert isinstance(ser.data, Mapping), '`.data` must be dict. Reality: {}.'.format(type(ser.data))
         for k, v in six.iteritems(ser.data):
             if k in data:
                 assert v == data[k], 'Object attribute `{}` must be `{}`, reality `{}`.'.format(k, v, data[k])
@@ -425,7 +428,7 @@ def test_instance_object_serializer(self):
         # Now we feed the data completely.
         data = self.__create_params(fullness='full')
         ser = self.serializer_class(instance=self.__create_object(data))
-        assert isinstance(ser.data, typing.Mapping), '`.data` must be dict. Reality: {}.'.format(type(ser.data))
+        assert isinstance(ser.data, Mapping), '`.data` must be dict. Reality: {}.'.format(type(ser.data))
         for k, v in six.iteritems(ser.data):
             if k in data:
                 assert v == data[k], 'Object attribute `{}` must be `{}`, reality `{}`.'.format(k, v, data[k])
@@ -440,12 +443,12 @@ def test_instance_dict_serializer(self):
         """
         # First we feed him an empty object..
         ser = self.serializer_class(instance=self.__create_params(fullness='empty'))
-        assert isinstance(ser.data, typing.Mapping), '`.data` must be dict. Reality: {}.'.format(type(ser.data))
+        assert isinstance(ser.data, Mapping), '`.data` must be dict. Reality: {}.'.format(type(ser.data))
 
         # Now we feed the data partially.
         data = self.__create_params(fullness='middle')
         ser = self.serializer_class(instance=data)
-        assert isinstance(ser.data, typing.Mapping), '`.data` must be dict. Reality: {}.'.format(type(ser.data))
+        assert isinstance(ser.data, Mapping), '`.data` must be dict. Reality: {}.'.format(type(ser.data))
         for k, v in six.iteritems(ser.data):
             if k in data:
                 assert v == data[k], 'Object attribute`{}` must be `{}`, reality `{}`.'.format(k, v, data[k])
@@ -455,7 +458,7 @@ def test_instance_dict_serializer(self):
         # Now we feed the data completely.
         data = self.__create_params(fullness='full')
         ser = self.serializer_class(instance=data)
-        assert isinstance(ser.data, typing.Mapping), '`.data` must be dict. Reality: {}.'.format(type(ser.data))
+        assert isinstance(ser.data, Mapping), '`.data` must be dict. Reality: {}.'.format(type(ser.data))
         for k, v in six.iteritems(ser.data):
             if k in data:
                 assert v == data[k], 'Object attribute `{}` must be `{}`, reality `{}`.'.format(k, v, data[k])