DecimalField's validate_precision incorrectly calculates total_digits for decimals smaller than 1

[mahdirahimi1999]

The DecimalField.validate_precision method incorrectly calculates the total number of digits for decimal values smaller than 1. This leads to valid inputs being rejected because the method appears to count the number of decimal places rather than the number of significant digits.

---

Steps to Reproduce

This script demonstrates the behavior. A DecimalField is configured with max_digits=3. It then fails to validate the value 0.0125, which has exactly 3 significant digits (1, 2, 5).

from decimal import Decimal
from rest_framework.fields import DecimalField
from rest_framework.exceptions import ValidationError

validator = DecimalField(max_digits=3, decimal_places=5) # decimal_places is large to not interfere.

value = Decimal('0.0125')

print(f"Validating '{value}' with max_digits={validator.max_digits}...")

try:
    validator.to_internal_value(value)
    print("✅ SUCCESS: The value was correctly validated.")
except ValidationError as e:
    print(f"❌ FAILED: The validator incorrectly rejected a valid value.")
    print(f"   Error: {e.detail}")

---

Expected Behavior

The script should execute without raising an exception, as 0.0125 (with 3 significant digits) does not violate the max_digits=3 constraint.

Validating '0.0125' with max_digits=3...
✅ SUCCESS: The value was correctly validated.

---

Actual Behavior

The script raises a ValidationError, incorrectly rejecting the valid input.

Validating '0.0125' with max_digits=3...
❌ FAILED: The validator incorrectly rejected a valid value.
   Error: [ErrorDetail(string='Ensure that there are no more than 3 digits in total.', code='max_digits')]

---

Analysis

The root cause is in the final else block of the validate_precision method:

# from rest_framework/fields.py
...
    else:
        # For values like 0.001234
        total_digits = abs(exponent) # <-- This is the issue
        ...

For Decimal('0.0125'), the tuple is (sign=0, digittuple=(1, 2, 5), exponent=-4). The logic enters the else block and incorrectly sets total_digits to abs(exponent), resulting in 4. The validation then fails because 4 > 3.

This is inconsistent with the goal of validating significant digits. For example:

• Decimal('0.0925') (3 significant digits) is incorrectly calculated as having 4 digits.
• Decimal('0.00015') (2 significant digits) is incorrectly calculated as having 5 digits.

This behavior makes it difficult to use DecimalField for precise scientific or financial values where leading zeros are only placeholders.

---

Possible Solution

A more accurate approach would be to calculate total_digits based on the length of the digittuple in this case:

# A potential change in the else block:
total_digits = len(digittuple)

Using value.normalize() at the beginning of the method could also provide a more consistent decimal representation before validation.

---

I'd be happy to work on a pull request for this if the maintainers agree this is a bug.

[browniebroke]

From the docs:

max_digits The maximum number of digits allowed in the number. It must be either None or an integer greater than or equal to decimal_places.

In your example, decimal_places is greater than max_digits.

I haven't looked at the code yet, but what you describe with significant digits doesn't seem to match what is documented...

[mahdirahimi1999]

Good point, thanks. You're right — my first example violated the max_digits >= decimal_places rule.

Let's try a different example that follows the documentation, but I believe still highlights the underlying ambiguity.

---

# This configuration is valid (5 >= 4)
validator = DecimalField(max_digits=5, decimal_places=4)

# This value has 3 significant digits and 4 decimal places.
# It should be valid.
value = Decimal('0.0125')

In this case, the validation passes.
However, the internal logic in validate_precision still seems inconsistent.

For Decimal('0.0125'), it calculates total_digits as 4 (from abs(exponent)), while the number of significant digits is actually 3.

---

Confusing Interpretation

This leads to a confusing interpretation of what max_digits is meant to control. For instance:

• Decimal('0.0125') is treated as having 4 digits.
• Decimal('0.1234') is also treated as having 4 digits.

The core of the issue seems to be the definition of "total digits" for numbers less than 1.

---

Is total_digits meant to be:

• The number of significant digits?
  If so, the current calculation seems off.
• Something else entirely?
  If so, the behavior is at least unintuitive.

Clarifying the intended behavior of max_digits for these cases would be helpful.

[browniebroke]

The argument is called max_digits, not significant_digits, and I'm not sure where you got the "significant digits" from, but I don't think it's ever mentioned as such in our docs? That may be an important concept for decimal/scientific notation more generally, but it's not really what we're talking about here.

I think the whole point is to have:

• max_decimal_places: how many number can be after the decimal: (XXX.XX -> max_decimal_places = 2)
• max_digits: maximum number of digits, whole + decimal (XXX.XX -> max_digits = 5)
• this set the max_whole_digits to 3 here

Also, this test pass now, so the value is now validated correctly (yes, to_internal_value takes a string and returns a Decimal):

def test_decimal_field_issue():
    field = serializers.DecimalField(max_digits=5, decimal_places=4)
    input_value = '0.0125'
    internal_value = field.to_internal_value(input_value)
    assert internal_value == Decimal('0.0125')

[mahdirahimi1999]

The argument is called max_digits, not significant_digits, and I'm not sure where you got the "significant digits" from, but I don't think it's ever mentioned as such in our docs? That may be an important concept for decimal/scientific notation more generally, but it's not really what we're talking about here.

I think the whole point is to have:

• max_decimal_places: how many number can be after the decimal: (XXX.XX -> max_decimal_places = 2)
• max_digits: maximum number of digits, whole + decimal (XXX.XX -> max_digits = 5)
• this set the max_whole_digits to 3 here

Also, this test pass now, so the value is now validated correctly (yes, to_internal_value takes a string and returns a Decimal):

def test_decimal_field_issue():
    field = serializers.DecimalField(max_digits=5, decimal_places=4)
    input_value = '0.0125'
    internal_value = field.to_internal_value(input_value)
    assert internal_value == Decimal('0.0125')

Thanks for the detailed explanation. That clarifies the intended behavior perfectly.