UniqueTogetherValidator validation is not made on passed data using many

[ghost]

When using UniqueTogetherValidator in a serializer and passing a list of dict as data with many=True, unicity is not checked between passed data.

Exemple

# models.py
from django.db import models
from django.db.models import UniqueConstraint


class Pet(models.Model):
    name = models.CharField(max_length=100)
    animal_type = models.CharField(max_length=100)
    can_fly = models.BooleanField(null=True)

    class Meta:
        constraints = [
            UniqueConstraint(
                fields=["name", "animal_type"],
                name="unique_pet",
            )
        ]

# serializers.py
from rest_framework import serializers
from pet.models import Pet


class PetSerializer(serializers.ModelSerializer):
    class Meta:
        model = Pet
        fields = ("name", "animal_type", "can_fly")

# in shell
>>> from pet.serializers import PetSerializer
>>> s = PetSerializer(data=[{"name":"Nita", "animal_type":"mammal"}, {"name":"Nita", "animal_type":"mammal"}], many=True)
>>> s.is_valid()
True
>>> s.save() # raises django.db.utils.IntegrityError: UNIQUE constraint failed: pet_pet.name, pet_pet.animal_type

I'm currently correcting that using

class ListSerializer(serializers.ListSerializer):
    def validate(self, attrs):
        self._validate_unique_fields(attrs)
        return attrs

    def _validate_unique_fields(self, attrs):
        unique_validators = [
            validator
            for validator in self.child.Meta.validators
            if isinstance(validator, validators.UniqueTogetherValidator)
        ]
        for validator in unique_validators:
            valid_items = set()

            for i, item in enumerate(attrs, start=1):
                representation = tuple(item[field] for field in validator.fields)
                if representation in valid_items:
                    raise serializers.ValidationError(
                        _("The item at index {idx} already exists").format(idx=i),
                        code="unique",
                    )
                valid_items.add(representation)

and it thinks DRF should handle such cases (in a better way than O(n^2)) except there is a reason to not.