Support for partial updates (when `drf_serializer` is passed `partial=True`)

[oerd]

The standard DRF serializers allow for partial validation (i.e. by passing partial=True) during a "partial update" (a PATCH method).
The current workaround requires making all fields optional, which is not ideal.

Is this something you'd fix in the drf-pydantic library?

[georgebv]

@oerd can you provide an example of how you think this would look like? It is possible to do partial validation in pydantic too, I just want to see what it means in this context.

[oerd]

Hey @georgebv I have scratched my itch in the meanwhile. I hacked together a mixin that merges incoming request data with the original object to perform validation. I can up the code and create a minimal reproduction of the bug with a test case.

It will take me a few days to get this done.

[oerd]

Hey @georgeb I finally got some time to look into this.

Here's a test case to surface my issue:

class TestPartialUpdateSerializer:
    def test_partial_update_merges_fields(self):
        """
        Test that PartialUpdateSerializer correctly merges existing instance data
        with partial update data before validation.
        """

        # 1. Define a Pydantic model with required fields and defaults
        class MyModel(BaseModel):
            drf_serializer = DrfPydanticSerializer
            drf_config: ClassVar[dict] = {"validate_pydantic": True, "from_attributes": True}
            model_config = ConfigDict(from_attributes=True)

            name: str
            age: int
            tags: list[str] = []

        # 2. Mock a Django-like instance
        class MockInstance:
            def __init__(self, name, age, tags):
                self.name = name
                self.age = age
                self.tags = tags

        age = 30
        instance = MockInstance(name="Old Name", age=age, tags=["old_tag"])

        # 3. Create a serializer with partial=True and update only 'tags'
        data = {"tags": ["new_tag"]}
        serializer = MyModel.drf_serializer(instance, data=data, partial=True)

        # 4. Validate
        assert serializer.is_valid(), serializer.errors

        # 5. Verify validated_data contains the updated tags AND the original other fields
        assert serializer.validated_data["tags"] == ["new_tag"]

        # Also verify that the internal pydantic model state was valid
        pydantic_instance = serializer.pydantic_instance
        assert pydantic_instance.name == "Old Name"  # Should be preserved from instance
        assert pydantic_instance.age == age  # Should be preserved from instance
        assert pydantic_instance.tags == ["new_tag"]  # Should be updated

I have a complete test suite for my partial-mixin, but let me know first if I'm my use of the DRF serializers is wrong or off somehow.

Edit: I ran into this while sending a PATCH http request (with partial serializer data) to an API endpoint that is normally handled by the UpdateModelMixin

[oerd]

I believe this analysis (from Deepwiki) might be of help.

[georgebv]

@oerd this test looks right, except for the part where you are manually setting drf_serializer = DrfPydanticSerializer (unless this is your custom serializer you define elsewhere?). Would you like to submit a PR? I think defining the right test case here is 90% of work.

[oerd]

I'm setting drf_serializer to a class CustomSerializer(PartialMixin, DrfPydanticSerializer): pass.

Yes sure, I'll whip up a PR and once we're happy with the test case we can work on addressing it.