Django FloatField with choices does not work properly in ModelSerializer

[karlosss]

Hello! Assume the following model:

class MyModel(models.Model):
    myfield = models.FloatField(choices=((0.5, 0.5), (1.0, 1.0), (1.5, 1.5)))

and a serializer:

class MySerializer(ModelSerializer):
    class Meta:
        model = MyModel
        fields = "__all__"

Then, if i do a request to the serializer with {"myfield": 1}, i get [ErrorDetail(string='"1" is not a valid choice.', code='invalid_choice')]

Is this the expected behavior?

[2ykwang]

This error occurs because the type allowed by the serializer and the input data type do not match. [ref source]

Soultion A

Override serializers.ChoiceField to cast int data.

class MyModel(models.Model):
    MYFIELD_CHOICES = ((0.5, 0.5), (1.0, 1.0), (1.5, 1.5))

    myfield = models.FloatField(choices=MYFIELD_CHOICES)

class CustomChoiceField(serializers.ChoiceField):
    def to_internal_value(self, data):
        # type casting
        if isinstance(data, int):
            return float(data)
        
        return super().to_internal_value(data)

class MySerializer(serializers.ModelSerializer):
    myfield = CustomChoiceField(choices=MyModel.MYFIELD_CHOICES)

    class Meta:
        model = MyModel
        fields = "__all__"

Solution B

Override the serializer to_internal_value method to convert the value of myfield to a float type.

class MySerializer(serializers.ModelSerializer):
    class Meta:
        model = MyModel
        fields = "__all__"

    def to_internal_value(self, data):
        value = data.get("myfield")
        if isinstance(value, int):
            data["myfield"] = float(value)

        return super().to_internal_value(data)

[karlosss]

sorry for a late reply... yes, i actually used something like workaround B in the project, however i am still unsure if this should be the behavior of DRF...

if you let's say have an integer field my_field and store this

{"my_field": "2"}

it will just convert the 2 to integer and store it without any errors... why don't we convert to the target type first and only then check for the choice list?

[hoonkii]

ModelSerializer generate ChoiceField when you represent choice in model field.
Let's see the ModelSerializer's code.

def build_standard_field(self, field_name, model_field):
        """
        Create regular model fields.
        """
        field_mapping = ClassLookupDict(self.serializer_field_mapping)

        field_class = field_mapping[model_field]
        field_kwargs = get_field_kwargs(field_name, model_field)

        # Special case to handle when a OneToOneField is also the primary key
        if model_field.one_to_one and model_field.primary_key:
            field_class = self.serializer_related_field
            field_kwargs['queryset'] = model_field.related_model.objects

        if 'choices' in field_kwargs:
            # Fields with choices get coerced into `ChoiceField`
            # instead of using their regular typed field.
            field_class = self.serializer_choice_field

In the code, myfield = models.FloatField(choices=MYFIELD_CHOICES) myfield does not generate serializers.FloatField. it generate serializers.ChoiceField. That's why casting to float is not possible.

Let's see the ChoiceField code.

def to_internal_value(self, data):
        if data == '' and self.allow_blank:
            return ''

        try:
            return self.choice_strings_to_values[str(data)]
        except KeyError:
            self.fail('invalid_choice', input=data)

--
self.choice_strings_to_values = {
            str(key): key for key in self.choices
        }

As you can see, a dictionary is created based on the value converted to a string.
When retrieving the actual value, convert the input value to a string and then retrieve the actual value from the dictionary.

---

It is possible to refactor the code of choicesField so that, when the type of choices is float, the value converted to an integer value is also added to the dictionary, but that doesn't seem like a good way. (In my opinion)

I think that the best way is to send it as 1.0 in the request. Or you can apply the above solution.