Add localization support to the FloatField (#4925)

* Add the "localize" and "coerce_to_string" constructor options to the FloatField like it is done for the DecimalField, in order to use the user current local to serialise and deserialise the float value if required.

*  * Restore imports in order to make isort test pass
 * Do string sanitization only if input is a string

* Fix string identification in python2.7

* Add documentation for the coerce_to_string and localize FloatField parameters

* Removes unneeded lines, and set default value for coerce_to_string to be False insteed of None

* Update FloatField signature docs

Author: kgeorgy

docs/api-guide/fields.md

@@ -250,10 +250,12 @@ A floating point representation.
 
 Corresponds to `django.db.models.fields.FloatField`.
 
-**Signature**: `FloatField(max_value=None, min_value=None)`
+**Signature**: `FloatField(coerce_to_string=False, max_value=None, min_value=None, localize=False)`
 
+- `coerce_to_string` Set to `True` if string values should be returned for the representation, or `False` if `float` objects should be returned. Defaults to `False`.
 - `max_value` Validate that the number provided is no greater than this value.
 - `min_value` Validate that the number provided is no less than this value.
+- `localize` Set to `True` to enable localization of input and output based on the current locale. This will also force `coerce_to_string` to `True`. Defaults to `False`. Note that data formatting is enabled if you have set `USE_L10N=True` in your settings file.
 
 ## DecimalField
 

rest_framework/fields.py

@@ -23,7 +23,9 @@
 )
 from django.utils.duration import duration_string
 from django.utils.encoding import is_protected_type, smart_text
-from django.utils.formats import localize_input, sanitize_separators
+from django.utils.formats import (
+    localize_input, number_format, sanitize_separators
+)
 from django.utils.functional import lazy
 from django.utils.ipv6 import clean_ipv6_address
 from django.utils.timezone import utc
@@ -954,6 +956,8 @@ class FloatField(Field):
     def __init__(self, **kwargs):
         self.max_value = kwargs.pop('max_value', None)
         self.min_value = kwargs.pop('min_value', None)
+        self.localize = kwargs.pop('localize', False)
+        self.coerce_to_string = kwargs.pop('coerce_to_string', False)
         super(FloatField, self).__init__(**kwargs)
         if self.max_value is not None:
             message = lazy(
@@ -970,15 +974,26 @@ def __init__(self, **kwargs):
 
     def to_internal_value(self, data):
 
-        if isinstance(data, six.text_type) and len(data) > self.MAX_STRING_LENGTH:
-            self.fail('max_string_length')
+        if isinstance(data, six.string_types):
+
+            data = smart_text(data).strip()
+
+            if len(data) > self.MAX_STRING_LENGTH:
+                self.fail('max_string_length')
+
+            if self.localize:
+                data = sanitize_separators(data)
 
         try:
             return float(data)
         except (TypeError, ValueError):
             self.fail('invalid')
 
     def to_representation(self, value):
+        if self.localize:
+            return number_format(value)
+        if self.coerce_to_string:
+            return str(float(value))
         return float(value)
 
 

tests/test_fields.py

@@ -952,6 +952,36 @@ class TestMinMaxFloatField(FieldValues):
     field = serializers.FloatField(min_value=1, max_value=3)
 
 
+class TestCoerceToStringFloatField(FieldValues):
+    valid_inputs = {}
+    invalid_inputs = {}
+    outputs = {
+        '1': str(1.0),
+        '0': str(0.0),
+        1: str(1.0),
+        0: str(0.0),
+        1.5: str(1.5),
+    }
+    field = serializers.FloatField(coerce_to_string=True)
+
+
+class TestLocalizedFloatField(TestCase):
+    @override_settings(USE_L10N=True, LANGUAGE_CODE='it')
+    def test_to_internal_value(self):
+        field = serializers.FloatField(localize=True)
+        self.assertEqual(field.to_internal_value('1,5'), 1.5)
+
+    @override_settings(USE_L10N=True, LANGUAGE_CODE=None, DECIMAL_SEPARATOR=',', THOUSAND_SEPARATOR='\'',
+                       NUMBER_GROUPING=3, USE_THOUSAND_SEPARATOR=True)
+    def test_to_representation(self):
+        field = serializers.FloatField(localize=True)
+        self.assertEqual(field.to_representation(1000.75), '1\'000,75')
+
+    def test_localize_forces_coerce_to_string(self):
+        field = serializers.FloatField(localize=True)
+        self.assertTrue(isinstance(field.to_representation(3), six.string_types))
+
+
 class TestDecimalField(FieldValues):
     """
     Valid and invalid values for `DecimalField`.