From 1544fafcb88029c7df30c3df89a326407c58f0e9 Mon Sep 17 00:00:00 2001
From: Sezer BOZKIR <natgho@hotmail.com>
Date: Wed, 25 Feb 2026 10:08:27 +0300
Subject: [PATCH 01/13] respecting ordered sequence while partial update is
 fixed

---
 rest_framework/fields.py       | 16 ++++++++++++----
 tests/test_serializer_lists.py | 22 ++++++++++++++++++++++
 2 files changed, 34 insertions(+), 4 deletions(-)

diff --git a/rest_framework/fields.py b/rest_framework/fields.py
index f5009a7303..7f6195ddd2 100644
--- a/rest_framework/fields.py
+++ b/rest_framework/fields.py
@@ -1675,9 +1675,6 @@ def __init__(self, **kwargs):
             self.validators.append(MinLengthValidator(self.min_length, message=message))
 
     def get_value(self, dictionary):
-        if self.field_name not in dictionary:
-            if getattr(self.root, 'partial', False):
-                return empty
         # We override the default field access in order to support
         # lists in HTML forms.
         if html.is_html_input(dictionary):
@@ -1685,7 +1682,18 @@ def get_value(self, dictionary):
             if len(val) > 0:
                 # Support QueryDict lists in HTML input.
                 return val
-            return html.parse_html_list(dictionary, prefix=self.field_name, default=empty)
+            # Check for indexed keys like field_name[0], field_name[1], etc.
+            # before returning empty on partial updates
+            html_list = html.parse_html_list(dictionary, prefix=self.field_name, default=empty)
+            if html_list is not empty:
+                return html_list
+            # If no HTML list data found and this is a partial update, return empty
+            if getattr(self.root, 'partial', False):
+                return empty
+            return html_list
+        if self.field_name not in dictionary:
+            if getattr(self.root, 'partial', False):
+                return empty
 
         return dictionary.get(self.field_name, empty)
 
diff --git a/tests/test_serializer_lists.py b/tests/test_serializer_lists.py
index f76451a5ad..ff405cdad4 100644
--- a/tests/test_serializer_lists.py
+++ b/tests/test_serializer_lists.py
@@ -426,6 +426,28 @@ class MultipleChoiceSerializer(serializers.Serializer):
         assert serializer.validated_data == {}
         assert serializer.errors == {}
 
+    def test_partial_listfield_with_indexed_keys(self):
+        """
+        Test that ListField respects ordered sequence in form data with partial updates.
+        Regression test for GitHub issue where indexed keys like field[0], field[1]
+        were not being parsed in partial updates.
+        """
+        class CommunitySerializer(serializers.Serializer):
+            colors = serializers.ListField(
+                allow_null=True,
+                child=serializers.CharField(label='Colors', max_length=7),
+                required=False
+            )
+        # Simulate form data with indexed keys
+        data = MultiValueDict({
+            'colors[0]': ['#ffffff'],
+            'colors[1]': ['#000000']
+        })
+        serializer = CommunitySerializer(data=data, partial=True)
+        assert serializer.is_valid(), f"Expected valid but got errors: {serializer.errors}"
+        assert 'colors' in serializer.validated_data
+        assert serializer.validated_data['colors'] == ['#ffffff', '#000000']
+
     def test_allow_empty_true(self):
         class ListSerializer(serializers.Serializer):
             update_field = serializers.IntegerField()

From 9caec6e15b0a539e10a223a5759a70674356eb87 Mon Sep 17 00:00:00 2001
From: Sezer BOZKIR <natgho@hotmail.com>
Date: Mon, 2 Mar 2026 12:28:51 +0300
Subject: [PATCH 02/13] getting field order is re-ordered for backward
 compatibility

---
 rest_framework/fields.py | 15 +++++++++++----
 1 file changed, 11 insertions(+), 4 deletions(-)

diff --git a/rest_framework/fields.py b/rest_framework/fields.py
index 220a40cb04..3c47a5e8f7 100644
--- a/rest_framework/fields.py
+++ b/rest_framework/fields.py
@@ -1683,19 +1683,26 @@ def get_value(self, dictionary):
         # We override the default field access in order to support
         # lists in HTML forms.
         if html.is_html_input(dictionary):
+            # First, try to get the value using the plain field name with getlist
+            # This handles standard HTML form list submissions like:
+            # <select multiple name="field"><option value="a">...
             val = dictionary.getlist(self.field_name, [])
             if len(val) > 0:
                 # Support QueryDict lists in HTML input.
                 return val
-            # Check for indexed keys like field_name[0], field_name[1], etc.
-            # before returning empty on partial updates
+            # Second, check for indexed keys like field[0], field[1], etc.
+            # This handles form submissions with explicit indices
             html_list = html.parse_html_list(dictionary, prefix=self.field_name, default=empty)
             if html_list is not empty:
                 return html_list
-            # If no HTML list data found and this is a partial update, return empty
+            # If no data found (neither plain list nor indexed keys)
+            # check if this is a partial update
             if getattr(self.root, 'partial', False):
                 return empty
-            return html_list
+            # For non-partial updates with no data, return empty
+            # This will trigger validation errors if the field is required
+            return empty
+        # Non-HTML input: standard dictionary access
         if self.field_name not in dictionary:
             if getattr(self.root, 'partial', False):
                 return empty

From 88ea74cafbeb1018500ce94424e8d230afbb56dd Mon Sep 17 00:00:00 2001
From: Sezer BOZKIR <natgho@hotmail.com>
Date: Mon, 2 Mar 2026 12:29:04 +0300
Subject: [PATCH 03/13] more detailed tests are added

---
 tests/test_serializer_lists.py | 102 +++++++++++++++++++++++++++++++++
 1 file changed, 102 insertions(+)

diff --git a/tests/test_serializer_lists.py b/tests/test_serializer_lists.py
index ff405cdad4..a10bfcf85a 100644
--- a/tests/test_serializer_lists.py
+++ b/tests/test_serializer_lists.py
@@ -448,6 +448,108 @@ class CommunitySerializer(serializers.Serializer):
         assert 'colors' in serializer.validated_data
         assert serializer.validated_data['colors'] == ['#ffffff', '#000000']
 
+    def test_partial_listfield_with_non_indexed_list(self):
+        """
+        Test that ListField still works with non-indexed list submission
+        in partial updates (backward compatibility check).
+        """
+        class CommunitySerializer(serializers.Serializer):
+            colors = serializers.ListField(
+                allow_null=True,
+                child=serializers.CharField(label='Colors', max_length=7),
+                required=False
+            )
+        # Simulate standard HTML form list (e.g., multiple select)
+        data = MultiValueDict({
+            'colors': ['#ffffff', '#000000']
+        })
+        serializer = CommunitySerializer(data=data, partial=True)
+        assert serializer.is_valid(), f"Expected valid but got errors: {serializer.errors}"
+        assert 'colors' in serializer.validated_data
+        assert serializer.validated_data['colors'] == ['#ffffff', '#000000']
+
+    def test_non_partial_listfield_with_indexed_keys(self):
+        """
+        Test that indexed keys work correctly in non-partial updates.
+        """
+        class CommunitySerializer(serializers.Serializer):
+            colors = serializers.ListField(
+                allow_null=True,
+                child=serializers.CharField(label='Colors', max_length=7),
+                required=False
+            )
+        # Simulate form data with indexed keys
+        data = MultiValueDict({
+            'colors[0]': ['#ffffff'],
+            'colors[1]': ['#000000']
+        })
+        serializer = CommunitySerializer(data=data, partial=False)
+        assert serializer.is_valid(), f"Expected valid but got errors: {serializer.errors}"
+        assert 'colors' in serializer.validated_data
+        assert serializer.validated_data['colors'] == ['#ffffff', '#000000']
+
+    def test_listfield_mixed_plain_and_indexed_keys(self):
+        """
+        Test behavior when both plain field and indexed keys are present.
+        Plain field should take precedence (getlist is checked first).
+        """
+        class CommunitySerializer(serializers.Serializer):
+            colors = serializers.ListField(
+                allow_null=True,
+                child=serializers.CharField(label='Colors', max_length=7),
+                required=False
+            )
+        # When both present, getlist should win (standard HTML form behavior)
+        data = MultiValueDict({
+            'colors': ['#aaaaaa', '#bbbbbb'],  # This should be used
+            'colors[0]': ['#ffffff'],           # These should be ignored
+            'colors[1]': ['#000000']
+        })
+        serializer = CommunitySerializer(data=data, partial=True)
+        assert serializer.is_valid(), f"Expected valid but got errors: {serializer.errors}"
+        assert 'colors' in serializer.validated_data
+        # Plain field values should take precedence
+        assert serializer.validated_data['colors'] == ['#aaaaaa', '#bbbbbb']
+
+    def test_partial_listfield_no_data_returns_empty(self):
+        """
+        Test that when no list data is provided in a partial update,
+        the field is correctly skipped (returns empty).
+        """
+        class CommunitySerializer(serializers.Serializer):
+            name = serializers.CharField()
+            colors = serializers.ListField(
+                allow_null=True,
+                child=serializers.CharField(label='Colors', max_length=7),
+                required=False
+            )
+        # Only update name, not colors
+        data = MultiValueDict({
+            'name': ['Community Name']
+        })
+        serializer = CommunitySerializer(data=data, partial=True)
+        assert serializer.is_valid(), f"Expected valid but got errors: {serializer.errors}"
+        assert 'name' in serializer.validated_data
+        assert 'colors' not in serializer.validated_data  # Should be skipped
+
+    def test_non_partial_listfield_standard_submission(self):
+        """
+        Test standard HTML form list submission without partial=True.
+        Ensures backward compatibility with existing behavior.
+        """
+        class CommunitySerializer(serializers.Serializer):
+            colors = serializers.ListField(
+                child=serializers.CharField(label='Colors', max_length=7),
+                required=True
+            )
+        # Standard multi-select form submission
+        data = MultiValueDict({
+            'colors': ['#ffffff', '#000000', '#ff0000']
+        })
+        serializer = CommunitySerializer(data=data, partial=False)
+        assert serializer.is_valid(), f"Expected valid but got errors: {serializer.errors}"
+        assert serializer.validated_data['colors'] == ['#ffffff', '#000000', '#ff0000']
+
     def test_allow_empty_true(self):
         class ListSerializer(serializers.Serializer):
             update_field = serializers.IntegerField()

From 0186c2532b7ef12f31fd381a7c70e28a1dbc8d43 Mon Sep 17 00:00:00 2001
From: Sezer BOZKIR <natgho@hotmail.com>
Date: Mon, 2 Mar 2026 12:29:23 +0300
Subject: [PATCH 04/13] .idea is added for Pycharm tmp files

---
 .gitignore | 2 ++
 1 file changed, 2 insertions(+)

diff --git a/.gitignore b/.gitignore
index d24c987176..e0280c51b9 100644
--- a/.gitignore
+++ b/.gitignore
@@ -19,3 +19,5 @@ coverage.*
 !.github
 !.gitignore
 !.pre-commit-config.yaml
+
+.idea
\ No newline at end of file

From 069c9fbc9b5edc0155f11ee7b0ba9501a79a9e6a Mon Sep 17 00:00:00 2001
From: Sezer BOZKIR <natgho@hotmail.com>
Date: Mon, 2 Mar 2026 13:31:42 +0300
Subject: [PATCH 05/13] reduntant check is removed, respecting o(n) search,
 checking prefixed keys is improved

---
 rest_framework/fields.py | 27 ++++++++++++---------------
 1 file changed, 12 insertions(+), 15 deletions(-)

diff --git a/rest_framework/fields.py b/rest_framework/fields.py
index 3c47a5e8f7..934e9632ab 100644
--- a/rest_framework/fields.py
+++ b/rest_framework/fields.py
@@ -1690,23 +1690,20 @@ def get_value(self, dictionary):
             if len(val) > 0:
                 # Support QueryDict lists in HTML input.
                 return val
-            # Second, check for indexed keys like field[0], field[1], etc.
-            # This handles form submissions with explicit indices
-            html_list = html.parse_html_list(dictionary, prefix=self.field_name, default=empty)
-            if html_list is not empty:
-                return html_list
-            # If no data found (neither plain list nor indexed keys)
-            # check if this is a partial update
-            if getattr(self.root, 'partial', False):
-                return empty
-            # For non-partial updates with no data, return empty
-            # This will trigger validation errors if the field is required
-            return empty
-        # Non-HTML input: standard dictionary access
-        if self.field_name not in dictionary:
+            # For partial updates, avoid the O(n) parse_html_list scan
+            # if neither the plain key nor any indexed keys are present
             if getattr(self.root, 'partial', False):
-                return empty
+                # Quick check: are there any keys matching field_name[*]?
+                prefix = self.field_name + '['
+                if not any(key.startswith(prefix) for key in dictionary):
+                    return empty
+            # Parse indexed keys (e.g., field[0], field[1])
+            # This handles form submissions with explicit indices
+            return html.parse_html_list(dictionary, prefix=self.field_name, default=empty)
 
+        # Non-HTML input: standard dictionary access
+        if self.field_name not in dictionary and getattr(self.root, 'partial', False):
+            return empty
         return dictionary.get(self.field_name, empty)
 
     def to_internal_value(self, data):

From e1c886388968c2e05334d486853f4cfc616d13f4 Mon Sep 17 00:00:00 2001
From: Sezer BOZKIR <natgho@hotmail.com>
Date: Mon, 2 Mar 2026 13:31:56 +0300
Subject: [PATCH 06/13] missing tests are added, more detailed

---
 tests/test_fields.py | 61 ++++++++++++++++++++++++++++++++++++++++++++
 1 file changed, 61 insertions(+)

diff --git a/tests/test_fields.py b/tests/test_fields.py
index b8b1e4caf7..b1b5da05ce 100644
--- a/tests/test_fields.py
+++ b/tests/test_fields.py
@@ -576,6 +576,67 @@ class TestSerializer(serializers.Serializer):
         assert serializer.is_valid()
         assert serializer.validated_data == {'scores': ['']}
 
+    def test_partial_update_with_indexed_keys(self):
+        """
+        Regression test for indexed HTML form keys with partial=True.
+        When data is passed as `colors[0]=#ffffff&colors[1]=#000000`
+        with partial=True, the field should parse indexed keys correctly.
+        """
+        class TestSerializer(serializers.Serializer):
+            colors = serializers.ListField(
+                allow_null=True,
+                child=serializers.CharField(max_length=7),
+                required=False
+            )
+            name = serializers.CharField(max_length=100, required=False)
+
+        serializer = TestSerializer(
+            data=QueryDict('colors[0]=#ffffff&colors[1]=#000000'),
+            partial=True
+        )
+        assert serializer.is_valid()
+        assert serializer.validated_data == {'colors': ['#ffffff', '#000000']}
+
+    def test_partial_update_omitted_list_field(self):
+        """
+        When a ListField is omitted in a partial update (and there are no
+        indexed keys for it), the field should return empty without triggering
+        an expensive O(n) scan via parse_html_list.
+        """
+        class TestSerializer(serializers.Serializer):
+            colors = serializers.ListField(
+                child=serializers.CharField(max_length=7),
+                required=False
+            )
+            name = serializers.CharField(max_length=100)
+
+        # colors is omitted, only name is provided
+        serializer = TestSerializer(
+            data=QueryDict('name=Test'),
+            partial=True
+        )
+        assert serializer.is_valid()
+        assert serializer.validated_data == {'name': 'Test'}
+        assert 'colors' not in serializer.validated_data
+
+    def test_partial_update_indexed_keys_ordering(self):
+        """
+        Indexed keys should preserve the correct order even when
+        they appear out of order in the QueryDict.
+        """
+        class TestSerializer(serializers.Serializer):
+            items = serializers.ListField(
+                child=serializers.IntegerField(),
+                required=False
+            )
+
+        serializer = TestSerializer(
+            data=QueryDict('items[2]=3&items[0]=1&items[1]=2'),
+            partial=True
+        )
+        assert serializer.is_valid()
+        assert serializer.validated_data == {'items': [1, 2, 3]}
+
 
 class TestCreateOnlyDefault:
     def setup_method(self):

From 1206cc48132b2871508710bae8b8af22b496ff69 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Asif=20Saif=20Uddin=20=7B=22Auvi=22=3A=22=E0=A6=85?=
 =?UTF-8?q?=E0=A6=AD=E0=A6=BF=22=7D?= <auvipy@gmail.com>
Date: Mon, 2 Mar 2026 16:39:49 +0600
Subject: [PATCH 07/13] Update tests/test_serializer_lists.py

Co-authored-by: Copilot <175728472+Copilot@users.noreply.github.com>
---
 tests/test_serializer_lists.py | 22 ----------------------
 1 file changed, 22 deletions(-)

diff --git a/tests/test_serializer_lists.py b/tests/test_serializer_lists.py
index a10bfcf85a..9c53238432 100644
--- a/tests/test_serializer_lists.py
+++ b/tests/test_serializer_lists.py
@@ -426,28 +426,6 @@ class MultipleChoiceSerializer(serializers.Serializer):
         assert serializer.validated_data == {}
         assert serializer.errors == {}
 
-    def test_partial_listfield_with_indexed_keys(self):
-        """
-        Test that ListField respects ordered sequence in form data with partial updates.
-        Regression test for GitHub issue where indexed keys like field[0], field[1]
-        were not being parsed in partial updates.
-        """
-        class CommunitySerializer(serializers.Serializer):
-            colors = serializers.ListField(
-                allow_null=True,
-                child=serializers.CharField(label='Colors', max_length=7),
-                required=False
-            )
-        # Simulate form data with indexed keys
-        data = MultiValueDict({
-            'colors[0]': ['#ffffff'],
-            'colors[1]': ['#000000']
-        })
-        serializer = CommunitySerializer(data=data, partial=True)
-        assert serializer.is_valid(), f"Expected valid but got errors: {serializer.errors}"
-        assert 'colors' in serializer.validated_data
-        assert serializer.validated_data['colors'] == ['#ffffff', '#000000']
-
     def test_partial_listfield_with_non_indexed_list(self):
         """
         Test that ListField still works with non-indexed list submission

From 3bb0f1634121ee126eb78964beaf229f75844ccf Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Sezer=20Bozk=C4=B1r?=
 <6623948+Natgho@users.noreply.github.com>
Date: Mon, 2 Mar 2026 18:25:42 +0300
Subject: [PATCH 08/13] Update tests/test_fields.py

Co-authored-by: Copilot <175728472+Copilot@users.noreply.github.com>
---
 tests/test_fields.py | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/tests/test_fields.py b/tests/test_fields.py
index b1b5da05ce..89abc51365 100644
--- a/tests/test_fields.py
+++ b/tests/test_fields.py
@@ -600,8 +600,8 @@ class TestSerializer(serializers.Serializer):
     def test_partial_update_omitted_list_field(self):
         """
         When a ListField is omitted in a partial update (and there are no
-        indexed keys for it), the field should return empty without triggering
-        an expensive O(n) scan via parse_html_list.
+        indexed keys for it), the field should be skipped and not included in
+        the validated data.
         """
         class TestSerializer(serializers.Serializer):
             colors = serializers.ListField(

From 12159c92f825ce2fb131a8f662734c09496372d8 Mon Sep 17 00:00:00 2001
From: Sezer BOZKIR <natgho@hotmail.com>
Date: Mon, 2 Mar 2026 18:27:32 +0300
Subject: [PATCH 09/13] comment is fixed for current solution explanation

---
 rest_framework/fields.py | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/rest_framework/fields.py b/rest_framework/fields.py
index 934e9632ab..a2e4c310c2 100644
--- a/rest_framework/fields.py
+++ b/rest_framework/fields.py
@@ -1690,8 +1690,8 @@ def get_value(self, dictionary):
             if len(val) > 0:
                 # Support QueryDict lists in HTML input.
                 return val
-            # For partial updates, avoid the O(n) parse_html_list scan
-            # if neither the plain key nor any indexed keys are present
+            # For partial updates, avoid calling parse_html_list unless indexed keys are present.
+            # This reduces unnecessary parsing overhead for omitted list fields.
             if getattr(self.root, 'partial', False):
                 # Quick check: are there any keys matching field_name[*]?
                 prefix = self.field_name + '['

From 1457bbcef5e23bc9d4fe57f81b91b63ea46b9eea Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Sezer=20Bozk=C4=B1r?=
 <6623948+Natgho@users.noreply.github.com>
Date: Mon, 2 Mar 2026 18:37:02 +0300
Subject: [PATCH 10/13] Update tests/test_serializer_lists.py

Co-authored-by: Copilot <175728472+Copilot@users.noreply.github.com>
---
 tests/test_serializer_lists.py | 62 ----------------------------------
 1 file changed, 62 deletions(-)

diff --git a/tests/test_serializer_lists.py b/tests/test_serializer_lists.py
index 9c53238432..da6f269364 100644
--- a/tests/test_serializer_lists.py
+++ b/tests/test_serializer_lists.py
@@ -466,68 +466,6 @@ class CommunitySerializer(serializers.Serializer):
         assert 'colors' in serializer.validated_data
         assert serializer.validated_data['colors'] == ['#ffffff', '#000000']
 
-    def test_listfield_mixed_plain_and_indexed_keys(self):
-        """
-        Test behavior when both plain field and indexed keys are present.
-        Plain field should take precedence (getlist is checked first).
-        """
-        class CommunitySerializer(serializers.Serializer):
-            colors = serializers.ListField(
-                allow_null=True,
-                child=serializers.CharField(label='Colors', max_length=7),
-                required=False
-            )
-        # When both present, getlist should win (standard HTML form behavior)
-        data = MultiValueDict({
-            'colors': ['#aaaaaa', '#bbbbbb'],  # This should be used
-            'colors[0]': ['#ffffff'],           # These should be ignored
-            'colors[1]': ['#000000']
-        })
-        serializer = CommunitySerializer(data=data, partial=True)
-        assert serializer.is_valid(), f"Expected valid but got errors: {serializer.errors}"
-        assert 'colors' in serializer.validated_data
-        # Plain field values should take precedence
-        assert serializer.validated_data['colors'] == ['#aaaaaa', '#bbbbbb']
-
-    def test_partial_listfield_no_data_returns_empty(self):
-        """
-        Test that when no list data is provided in a partial update,
-        the field is correctly skipped (returns empty).
-        """
-        class CommunitySerializer(serializers.Serializer):
-            name = serializers.CharField()
-            colors = serializers.ListField(
-                allow_null=True,
-                child=serializers.CharField(label='Colors', max_length=7),
-                required=False
-            )
-        # Only update name, not colors
-        data = MultiValueDict({
-            'name': ['Community Name']
-        })
-        serializer = CommunitySerializer(data=data, partial=True)
-        assert serializer.is_valid(), f"Expected valid but got errors: {serializer.errors}"
-        assert 'name' in serializer.validated_data
-        assert 'colors' not in serializer.validated_data  # Should be skipped
-
-    def test_non_partial_listfield_standard_submission(self):
-        """
-        Test standard HTML form list submission without partial=True.
-        Ensures backward compatibility with existing behavior.
-        """
-        class CommunitySerializer(serializers.Serializer):
-            colors = serializers.ListField(
-                child=serializers.CharField(label='Colors', max_length=7),
-                required=True
-            )
-        # Standard multi-select form submission
-        data = MultiValueDict({
-            'colors': ['#ffffff', '#000000', '#ff0000']
-        })
-        serializer = CommunitySerializer(data=data, partial=False)
-        assert serializer.is_valid(), f"Expected valid but got errors: {serializer.errors}"
-        assert serializer.validated_data['colors'] == ['#ffffff', '#000000', '#ff0000']
-
     def test_allow_empty_true(self):
         class ListSerializer(serializers.Serializer):
             update_field = serializers.IntegerField()

From b0066ab2c469ae2f86ade574e5905d865c32d1c5 Mon Sep 17 00:00:00 2001
From: Sezer BOZKIR <natgho@hotmail.com>
Date: Mon, 2 Mar 2026 18:59:21 +0300
Subject: [PATCH 11/13] standardized the errors

---
 tests/test_serializer_lists.py | 65 ++++++++++++++++++++++++++++++++--
 1 file changed, 63 insertions(+), 2 deletions(-)

diff --git a/tests/test_serializer_lists.py b/tests/test_serializer_lists.py
index da6f269364..85d90c1554 100644
--- a/tests/test_serializer_lists.py
+++ b/tests/test_serializer_lists.py
@@ -442,7 +442,7 @@ class CommunitySerializer(serializers.Serializer):
             'colors': ['#ffffff', '#000000']
         })
         serializer = CommunitySerializer(data=data, partial=True)
-        assert serializer.is_valid(), f"Expected valid but got errors: {serializer.errors}"
+        assert serializer.is_valid()
         assert 'colors' in serializer.validated_data
         assert serializer.validated_data['colors'] == ['#ffffff', '#000000']
 
@@ -462,10 +462,71 @@ class CommunitySerializer(serializers.Serializer):
             'colors[1]': ['#000000']
         })
         serializer = CommunitySerializer(data=data, partial=False)
-        assert serializer.is_valid(), f"Expected valid but got errors: {serializer.errors}"
+        assert serializer.is_valid()
         assert 'colors' in serializer.validated_data
         assert serializer.validated_data['colors'] == ['#ffffff', '#000000']
 
+    def test_listfield_mixed_plain_and_indexed_keys(self):
+        """
+        Test that when both plain field and indexed keys are present,
+        the plain field takes precedence (standard HTML form behavior).
+        """
+        class CommunitySerializer(serializers.Serializer):
+            colors = serializers.ListField(
+                allow_null=True,
+                child=serializers.CharField(label='Colors', max_length=7),
+                required=False
+            )
+        # When both present, getlist should win (standard HTML form behavior)
+        data = MultiValueDict({
+            'colors': ['#aaaaaa', '#bbbbbb'],  # This should be used
+            'colors[0]': ['#ffffff'],           # These should be ignored
+            'colors[1]': ['#000000']
+        })
+        serializer = CommunitySerializer(data=data, partial=True)
+        assert serializer.is_valid()
+        assert 'colors' in serializer.validated_data
+        # Plain field values should take precedence
+        assert serializer.validated_data['colors'] == ['#aaaaaa', '#bbbbbb']
+
+    def test_partial_listfield_no_data_returns_empty(self):
+        """
+        Test that when a ListField is omitted in partial updates,
+        it does not appear in validated_data (not even as an empty list).
+        """
+        class CommunitySerializer(serializers.Serializer):
+            name = serializers.CharField(max_length=100)
+            colors = serializers.ListField(
+                allow_null=True,
+                child=serializers.CharField(label='Colors', max_length=7),
+                required=False
+            )
+        data = MultiValueDict({
+            'name': ['Community Name']
+        })
+        serializer = CommunitySerializer(data=data, partial=True)
+        assert serializer.is_valid()
+        assert 'name' in serializer.validated_data
+        assert 'colors' not in serializer.validated_data  # Should be skipped
+
+    def test_non_partial_listfield_standard_submission(self):
+        """
+        Test standard HTML form list submission without partial=True.
+        Ensures backward compatibility with existing behavior.
+        """
+        class CommunitySerializer(serializers.Serializer):
+            colors = serializers.ListField(
+                child=serializers.CharField(label='Colors', max_length=7),
+                required=True
+            )
+        # Standard multi-select form submission
+        data = MultiValueDict({
+            'colors': ['#ffffff', '#000000', '#ff0000']
+        })
+        serializer = CommunitySerializer(data=data, partial=False)
+        assert serializer.is_valid()
+        assert serializer.validated_data['colors'] == ['#ffffff', '#000000', '#ff0000']
+
     def test_allow_empty_true(self):
         class ListSerializer(serializers.Serializer):
             update_field = serializers.IntegerField()

From acf688b8a0052664df2f79db8f458f31779cc38f Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Sezer=20Bozk=C4=B1r?=
 <6623948+Natgho@users.noreply.github.com>
Date: Mon, 2 Mar 2026 19:06:40 +0300
Subject: [PATCH 12/13] Update rest_framework/fields.py

Co-authored-by: Copilot <175728472+Copilot@users.noreply.github.com>
---
 rest_framework/fields.py | 14 ++++++++++----
 1 file changed, 10 insertions(+), 4 deletions(-)

diff --git a/rest_framework/fields.py b/rest_framework/fields.py
index a2e4c310c2..1081328f76 100644
--- a/rest_framework/fields.py
+++ b/rest_framework/fields.py
@@ -1683,12 +1683,18 @@ def get_value(self, dictionary):
         # We override the default field access in order to support
         # lists in HTML forms.
         if html.is_html_input(dictionary):
-            # First, try to get the value using the plain field name with getlist
+            # First, try to get the value using the plain field name with getlist.
             # This handles standard HTML form list submissions like:
             # <select multiple name="field"><option value="a">...
-            val = dictionary.getlist(self.field_name, [])
-            if len(val) > 0:
-                # Support QueryDict lists in HTML input.
+            try:
+                # Call getlist with a single argument to support duck-typed MultiDicts
+                # that do not accept a default parameter.
+                val = dictionary.getlist(self.field_name)
+            except (TypeError, KeyError, AttributeError):
+                # Fall back to treating the value as not provided.
+                val = []
+            if val:
+                # Support QueryDict lists and other list-like results in HTML input.
                 return val
             # For partial updates, avoid calling parse_html_list unless indexed keys are present.
             # This reduces unnecessary parsing overhead for omitted list fields.

From 733c2072a921154cd174974b8ac68cb7fbfd4823 Mon Sep 17 00:00:00 2001
From: Sezer BOZKIR <natgho@hotmail.com>
Date: Mon, 2 Mar 2026 19:25:02 +0300
Subject: [PATCH 13/13] listfield html input tests are seperated

---
 tests/test_serializer_lists.py | 83 ++++++++++++++++++----------------
 1 file changed, 45 insertions(+), 38 deletions(-)

diff --git a/tests/test_serializer_lists.py b/tests/test_serializer_lists.py
index 85d90c1554..f690559a8a 100644
--- a/tests/test_serializer_lists.py
+++ b/tests/test_serializer_lists.py
@@ -286,6 +286,51 @@ def test_validate_html_input(self):
         assert serializer.validated_data == expected_output
 
 
+class TestListFieldHTMLInput:
+    """
+    Tests for ListField with HTML form input, including indexed keys.
+    """
+
+    def test_listfield_with_indexed_keys(self):
+        """
+        Test that indexed keys (e.g., field[0], field[1]) work correctly
+        in HTML form submissions.
+        """
+        class CommunitySerializer(serializers.Serializer):
+            colors = serializers.ListField(
+                allow_null=True,
+                child=serializers.CharField(label='Colors', max_length=7),
+                required=False
+            )
+        # Simulate form data with indexed keys
+        data = MultiValueDict({
+            'colors[0]': ['#ffffff'],
+            'colors[1]': ['#000000']
+        })
+        serializer = CommunitySerializer(data=data)
+        assert serializer.is_valid()
+        assert 'colors' in serializer.validated_data
+        assert serializer.validated_data['colors'] == ['#ffffff', '#000000']
+
+    def test_listfield_standard_form_submission(self):
+        """
+        Test standard HTML form list submission (e.g., multi-select).
+        Ensures backward compatibility with existing behavior.
+        """
+        class CommunitySerializer(serializers.Serializer):
+            colors = serializers.ListField(
+                child=serializers.CharField(label='Colors', max_length=7),
+                required=True
+            )
+        # Standard multi-select form submission
+        data = MultiValueDict({
+            'colors': ['#ffffff', '#000000', '#ff0000']
+        })
+        serializer = CommunitySerializer(data=data)
+        assert serializer.is_valid()
+        assert serializer.validated_data['colors'] == ['#ffffff', '#000000', '#ff0000']
+
+
 class TestNestedListSerializerAllowEmpty:
     """Tests the behavior of allow_empty=False when a ListSerializer is used as a field."""
 
@@ -446,26 +491,6 @@ class CommunitySerializer(serializers.Serializer):
         assert 'colors' in serializer.validated_data
         assert serializer.validated_data['colors'] == ['#ffffff', '#000000']
 
-    def test_non_partial_listfield_with_indexed_keys(self):
-        """
-        Test that indexed keys work correctly in non-partial updates.
-        """
-        class CommunitySerializer(serializers.Serializer):
-            colors = serializers.ListField(
-                allow_null=True,
-                child=serializers.CharField(label='Colors', max_length=7),
-                required=False
-            )
-        # Simulate form data with indexed keys
-        data = MultiValueDict({
-            'colors[0]': ['#ffffff'],
-            'colors[1]': ['#000000']
-        })
-        serializer = CommunitySerializer(data=data, partial=False)
-        assert serializer.is_valid()
-        assert 'colors' in serializer.validated_data
-        assert serializer.validated_data['colors'] == ['#ffffff', '#000000']
-
     def test_listfield_mixed_plain_and_indexed_keys(self):
         """
         Test that when both plain field and indexed keys are present,
@@ -509,24 +534,6 @@ class CommunitySerializer(serializers.Serializer):
         assert 'name' in serializer.validated_data
         assert 'colors' not in serializer.validated_data  # Should be skipped
 
-    def test_non_partial_listfield_standard_submission(self):
-        """
-        Test standard HTML form list submission without partial=True.
-        Ensures backward compatibility with existing behavior.
-        """
-        class CommunitySerializer(serializers.Serializer):
-            colors = serializers.ListField(
-                child=serializers.CharField(label='Colors', max_length=7),
-                required=True
-            )
-        # Standard multi-select form submission
-        data = MultiValueDict({
-            'colors': ['#ffffff', '#000000', '#ff0000']
-        })
-        serializer = CommunitySerializer(data=data, partial=False)
-        assert serializer.is_valid()
-        assert serializer.validated_data['colors'] == ['#ffffff', '#000000', '#ff0000']
-
     def test_allow_empty_true(self):
         class ListSerializer(serializers.Serializer):
             update_field = serializers.IntegerField()