bug fixing. V 0.1.6

Author: nxexox

docs/release-notes.md

@@ -8,6 +8,13 @@ Medium version numbers (0.x.0) may include API changes, in line with the [deprec
 
 Major version numbers (x.0.0) are reserved for substantial project milestones.
 
+### 0.1.6
+
+**Date**: [18th December 2018].
+
+* Fix internal logic on validation field binding.
+* Fix settings internal validators on fields.
+
 ### 0.1.5
 
 **Date**: [12th December 2018].

rest_framework/__init__.py

@@ -8,7 +8,7 @@
          __/ |
         |___/
 """
-VERSION = (0, 1, 5)
+VERSION = (0, 1, 6)
 
 __title__ = 'Python-Rest-Framework'
 __author__ = 'Deys Timofey'

rest_framework/serializers/fields.py

@@ -3,7 +3,7 @@
 
 """
 import re
-import collections
+import typing
 import datetime
 import json
 
@@ -48,7 +48,7 @@ def get_attribute(obj, attr_name):
 
     """
     # Search attribute.
-    if isinstance(obj, collections.Mapping):
+    if isinstance(obj, typing.Mapping):
         attr = obj[attr_name]
     else:
         attr = getattr(obj, attr_name)
@@ -305,6 +305,10 @@ def run_validation(self, data):
         # First, we validate to be bound.
         is_empty, data = self.validate_empty_values(data)
 
+        # If empty data and field not required.
+        if is_empty and not self.required:
+            return data
+
         # Process raw data.
         value = self.to_internal_value(data)
         # Run validators.
@@ -358,16 +362,16 @@ def __init__(self, min_length=None, max_length=None, trim_whitespace=False, allo
 
         """
         super().__init__(*args, **kwargs)
-        self.max_length = max_length
-        self.min_length = min_length
+        self.max_length = max_length if max_length is None else int(max_length)
+        self.min_length = min_length if min_length is None else int(min_length)
         self.trim_whitespace = trim_whitespace
         self.allow_blank = allow_blank
 
         # Added validators.
-        if self.max_length:
+        if self.max_length is not None:
             message = self.error_messages['max_length'].format(max_length=self.max_length)
             self.validators.append(MaxLengthValidator(max_length, message=message))
-        if self.min_length:
+        if self.min_length is not None:
             message = self.error_messages['min_length'].format(min_length=self.min_length)
             self.validators.append(MinLengthValidator(self.min_length, message=message))
 
@@ -444,10 +448,10 @@ def __init__(self, min_value=None, max_value=None, *args, **kwargs):
         self.max_value = max_value if max_value is None else int(max_value)
 
         # Added validators.
-        if self.min_value:
+        if self.min_value is not None:
             message = self.error_messages['min_value'].format(min_value=self.min_value)
             self.validators.append(MinValueValidator(self.min_value, message=message))
-        if self.max_value:
+        if self.max_value is not None:
             message = self.error_messages['max_value'].format(max_value=self.max_value)
             self.validators.append(MaxValueValidator(self.max_value, message=message))
 
@@ -508,14 +512,14 @@ def __init__(self, min_value=None, max_value=None, *args, **kwargs):
 
         """
         super().__init__(*args, **kwargs)
-        self.min_value = min_value if min_value is None else int(min_value)
-        self.max_value = max_value if max_value is None else int(max_value)
+        self.min_value = min_value if min_value is None else float(min_value)
+        self.max_value = max_value if max_value is None else float(max_value)
 
         # Added validators.
-        if self.min_value:
+        if self.min_value is not None:
             message = self.error_messages['min_value'].format(min_value=self.min_value)
             self.validators.append(MinValueValidator(self.min_value, message=message))
-        if self.max_value:
+        if self.max_value is not None:
             message = self.error_messages['max_value'].format(max_value=self.max_value)
             self.validators.append(MaxValueValidator(self.max_value, message=message))
 
@@ -688,8 +692,8 @@ def __init__(self, child=None, min_length=None, max_length=None, allow_empty=Fal
         """
         super().__init__(*args, **kwargs)
         self.child = child or self.child
-        self.min_length = min_length
-        self.max_length = max_length
+        self.min_length = min_length if min_length is None else int(min_length)
+        self.max_length = max_length if max_length is None else int(max_length)
         self.allow_empty = bool(allow_empty)
 
         # Check field `child`.
@@ -699,10 +703,10 @@ def __init__(self, child=None, min_length=None, max_length=None, allow_empty=Fal
         self.child.bind(field_name='', parent=self)  # Bind child field.
 
         # Added validators.
-        if self.max_length:
+        if self.max_length is not None:
             message = self.error_messages['max_length'].format(max_length=self.max_length)
             self.validators.append(MaxLengthValidator(max_length, message=message))
-        if self.min_length:
+        if self.min_length is not None:
             message = self.error_messages['min_length'].format(min_length=self.min_length)
             self.validators.append(MinLengthValidator(self.min_length, message=message))
 
@@ -721,7 +725,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, collections.Mapping), not hasattr(data, '__iter__'))):
+        if any((isinstance(data, type('')), isinstance(data, typing.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,6 +4,7 @@
 """
 import copy
 import inspect
+from typing import Mapping
 from collections import OrderedDict
 
 import six
@@ -107,7 +108,7 @@ def __init__(self, instance=None, data=None, *args, **kwargs):
         """
         super().__init__(*args, **kwargs)
         self.instance = instance
-        if isinstance(data, dict):
+        if isinstance(data, Mapping):
             self.initial_data = data
 
     def __new__(cls, *args, **kwargs):

rest_framework/tests/test_fields.py

@@ -20,7 +20,7 @@
     RequiredValidator, MaxValueValidator, MinValueValidator, MinLengthValidator, MaxLengthValidator
 )
 
-from .serializers_for_tests import SerializerMethodFieldDefault, SerializerMethodFieldSingle
+from rest_framework.tests.serializers_for_tests import SerializerMethodFieldDefault, SerializerMethodFieldSingle
 
 
 class BaseFieldTestCase(TestCase):
@@ -481,7 +481,7 @@ class CharFieldTest(BaseFieldTestCase):
         {'data': {'data': 123}, 'return': '123'},
         {'data': {'data': 'qwe'}, 'return': 'qwe'},
         {'data': {'data': None}, 'exceptions': (ValidationError,)},
-        {'data': {'data': None}, 'params': {'required': False}, 'exceptions': (ValidationError,)},
+        {'data': {'data': None}, 'params': {'required': False}, 'return': None},
         {'data': {'data': ''}, 'params': {'allow_blank': False}, 'exceptions': (ValidationError,)},
         {'data': {'data': ''}, 'params': {'allow_blank': True}, 'return': ''},
         {'data': {'data': '   '}, 'params': {'allow_blank': True, 'trim_whitespace': True}, 'return': ''},
@@ -758,7 +758,7 @@ class TestTimeField(BaseFieldTestCase):
         {'data': {'data': datetime.time()}, 'return': datetime.time()},
         {'data': {'data': datetime.time(10, 10)}, 'return': datetime.time(10, 10)},
         {'data': {'data': None}, 'exceptions': (ValidationError,)},
-        {'data': {'data': None}, 'params': {'required': False}, 'exceptions': (ValidationError,)},
+        {'data': {'data': None}, 'params': {'required': False}, 'return': None},
         {'data': {'data': None}, 'params': {'default': datetime.time()}, 'return': datetime.time()},
     )  # Cases, to test the performance of `.run_validation()`.
 
@@ -801,7 +801,7 @@ class TestDateField(BaseFieldTestCase):
         {'data': {'data': datetime.datetime.now()}, 'exceptions': (ValidationError,)},
         {'data': {'data': '2018-10'}, 'params': {'input_format': '%Y-%m'}, 'return': datetime.date(2018, 10, 1)},
         {'data': {'data': None}, 'exceptions': (ValidationError,)},
-        {'data': {'data': None}, 'params': {'required': False}, 'exceptions': (ValidationError,)},
+        {'data': {'data': None}, 'params': {'required': False}, 'return': None},
         {'data': {'data': None}, 'params': {'default': datetime.date(2018, 1, 1)}, 'return': datetime.date(2018, 1, 1)},
     )  # Cases, to test the performance of `.run_validation()`.
 
@@ -847,7 +847,7 @@ class TestDateTimeField(BaseFieldTestCase):
         {'data': {'data': __now_for_test.strftime(DateTimeField.input_format)}, 'return': __now_for_test},
         {'data': {'data': '2018-10'}, 'params': {'input_format': '%Y-%m'}, 'return': datetime.datetime(2018, 10, 1)},
         {'data': {'data': None}, 'exceptions': (ValidationError,)},
-        {'data': {'data': None}, 'params': {'required': False}, 'exceptions': (ValidationError,)},
+        {'data': {'data': None}, 'params': {'required': False}, 'return': None},
         {'data': {'data': None}, 'params': {'default': datetime.datetime(2018, 1, 1)}, 'return': datetime.datetime(2018, 1, 1)},
     )  # Cases, to test the performance of `.run_validation()`.
 
@@ -897,7 +897,7 @@ class TestJsonField(BaseFieldTestCase):
         {'data': {'data': 'asd'}, 'exceptions': (ValidationError,)},
         {'data': {'data': 123}, 'exceptions': (ValidationError,)},
         {'data': {'data': None}, 'exceptions': (ValidationError,)},
-        {'data': {'data': None}, 'params': {'required': False}, 'exceptions': (ValidationError,)},  # TODO: FIXME
+        {'data': {'data': None}, 'params': {'required': False}, 'return': None},  # TODO: FIXME
     )  # Cases, to test the performance of `.run_validation()`.
 
 
@@ -941,7 +941,7 @@ class TestDictField(BaseFieldTestCase):
         {'data': {'data': 'asd'}, 'exceptions': (ValidationError,)},
         {'data': {'data': 123}, 'exceptions': (ValidationError,)},
         {'data': {'data': None}, 'exceptions': (ValidationError,)},
-        {'data': {'data': None}, 'params': {'required': False}, 'exceptions': (ValidationError,)},  # TODO: FIXME
+        {'data': {'data': None}, 'params': {'required': False}, 'return': None},  # TODO: FIXME
         {'data': {'data': {123: [123]}}, 'params': {'child': IntegerField()}, 'exceptions': (ValidationError,)}
     )  # Cases, to test the performance of `.run_validation()`.
 

rest_framework/tests/test_serializers.py

@@ -4,7 +4,8 @@
 2. We test the external interface as they should work.
 
 """
-import collections
+# import collections
+import typing
 from unittest import TestCase
 
 import six
@@ -311,7 +312,7 @@ def __create_object(self, data):
 
         """
         return type('object', (object,), {
-            key: self.__create_object(val) if isinstance(val, collections.Mapping) else val
+            key: self.__create_object(val) if isinstance(val, typing.Mapping) else val
             for key, val in six.iteritems(data)
         })
 
@@ -358,10 +359,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, collections.Mapping), \
+        assert isinstance(ser.errors, typing.Mapping), \
             '`.errors` must be dict. Reality: {}.'.format(type(ser.errors))
         assert len(ser.errors) > 0, '`.errors` must contain errors.'
-        assert isinstance(ser.validated_data, collections.Mapping), \
+        assert isinstance(ser.validated_data, typing.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)
 
@@ -376,10 +377,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, collections.Mapping), \
+        assert isinstance(ser.errors, typing.Mapping), \
             '`.errors` must be dict. Reality: {}.'.format(type(ser.errors))
         assert len(ser.errors) > 0, '`.errors` must contain errors.'
-        assert isinstance(ser.validated_data, collections.Mapping), \
+        assert isinstance(ser.validated_data, typing.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)
 
@@ -388,10 +389,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, collections.Mapping), \
+        assert isinstance(ser.errors, typing.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, collections.Mapping), \
+        assert isinstance(ser.validated_data, typing.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.
@@ -409,12 +410,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, collections.Mapping), '`.data` must be dict. Reality: {}'.format(type(ser.data))
+        assert isinstance(ser.data, typing.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, collections.Mapping), '`.data` must be dict. Reality: {}.'.format(type(ser.data))
+        assert isinstance(ser.data, typing.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])
@@ -424,7 +425,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, collections.Mapping), '`.data` must be dict. Reality: {}.'.format(type(ser.data))
+        assert isinstance(ser.data, typing.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])
@@ -439,12 +440,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, collections.Mapping), '`.data` must be dict. Reality: {}.'.format(type(ser.data))
+        assert isinstance(ser.data, typing.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, collections.Mapping), '`.data` must be dict. Reality: {}.'.format(type(ser.data))
+        assert isinstance(ser.data, typing.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])
@@ -454,7 +455,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, collections.Mapping), '`.data` must be dict. Reality: {}.'.format(type(ser.data))
+        assert isinstance(ser.data, typing.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])