From d5f228dd0012fe514e552224c1501782237eecb0 Mon Sep 17 00:00:00 2001 From: Henrik Wahlgren Date: Wed, 16 Nov 2022 15:31:50 +0100 Subject: [PATCH] Possibility to remove trailing zeros on DecimalFields representation (#6514) * Added normalize parameter to DecimalField to be able to strip trailing zeros. Fixes #6151. * Updated docs to include normalize option on DecimalField * Fixed linting error in test_fields * Removed comment and renamed normalize to normalize_output as suggested in code review Co-authored-by: Tom Christie --- docs/api-guide/fields.md | 1 + rest_framework/fields.py | 6 +++++- tests/test_fields.py | 21 +++++++++++++++++++++ 3 files changed, 27 insertions(+), 1 deletion(-) diff --git a/docs/api-guide/fields.md b/docs/api-guide/fields.md index 0a96d0e0c..4b4ea83cc 100644 --- a/docs/api-guide/fields.md +++ b/docs/api-guide/fields.md @@ -295,6 +295,7 @@ Corresponds to `django.db.models.fields.DecimalField`. * `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. * `rounding` Sets the rounding mode used when quantising to the configured precision. Valid values are [`decimal` module rounding modes][python-decimal-rounding-modes]. Defaults to `None`. +* `normalize_output` Will normalize the decimal value when serialized. This will strip all trailing zeroes and change the value's precision to the minimum required precision to be able to represent the value without loosing data. Defaults to `False`. #### Example usage diff --git a/rest_framework/fields.py b/rest_framework/fields.py index 7f4c83b5d..88d606b28 100644 --- a/rest_framework/fields.py +++ b/rest_framework/fields.py @@ -963,10 +963,11 @@ class DecimalField(Field): MAX_STRING_LENGTH = 1000 # Guard against malicious string inputs. def __init__(self, max_digits, decimal_places, coerce_to_string=None, max_value=None, min_value=None, - localize=False, rounding=None, **kwargs): + localize=False, rounding=None, normalize_output=False, **kwargs): self.max_digits = max_digits self.decimal_places = decimal_places self.localize = localize + self.normalize_output = normalize_output if coerce_to_string is not None: self.coerce_to_string = coerce_to_string if self.localize: @@ -1079,6 +1080,9 @@ class DecimalField(Field): quantized = self.quantize(value) + if self.normalize_output: + quantized = quantized.normalize() + if not coerce_to_string: return quantized if self.localize: diff --git a/tests/test_fields.py b/tests/test_fields.py index 72ef23dca..3112fc2cc 100644 --- a/tests/test_fields.py +++ b/tests/test_fields.py @@ -1251,6 +1251,27 @@ class TestQuantizedValueForDecimal(TestCase): assert value == expected_digit_tuple +class TestNormalizedOutputValueDecimalField(TestCase): + """ + Test that we get the expected behavior of on DecimalField when normalize=True + """ + + def test_normalize_output(self): + field = serializers.DecimalField(max_digits=4, decimal_places=3, normalize_output=True) + output = field.to_representation(Decimal('1.000')) + assert output == '1' + + def test_non_normalize_output(self): + field = serializers.DecimalField(max_digits=4, decimal_places=3, normalize_output=False) + output = field.to_representation(Decimal('1.000')) + assert output == '1.000' + + def test_normalize_coeherce_to_string(self): + field = serializers.DecimalField(max_digits=4, decimal_places=3, normalize_output=True, coerce_to_string=False) + output = field.to_representation(Decimal('1.000')) + assert output == Decimal('1') + + class TestNoDecimalPlaces(FieldValues): valid_inputs = { '0.12345': Decimal('0.12345'),