fix: Fix multipart body file array

end_to_end_tests/golden-record/my_test_api_client/models/a_model.py

@@ -206,6 +206,7 @@ def to_dict(self) -> dict[str, Any]:
             not_required_nullable_model = self.not_required_nullable_model
 
         field_dict: dict[str, Any] = {}
+
         field_dict.update(
             {
                 "an_enum_value": an_enum_value,

end_to_end_tests/golden-record/my_test_api_client/models/body_upload_file_tests_upload_post.py

@@ -136,6 +136,7 @@ def to_dict(self) -> dict[str, Any]:
         field_dict: dict[str, Any] = {}
         for prop_name, prop in self.additional_properties.items():
             field_dict[prop_name] = prop.to_dict()
+
         field_dict.update(
             {
                 "some_file": some_file,
@@ -167,116 +168,88 @@ def to_dict(self) -> dict[str, Any]:
 
         return field_dict
 
-    def to_multipart(self) -> dict[str, Any]:
-        some_file = self.some_file.to_tuple()
+    def to_multipart(self) -> list[tuple[str, Any]]:
+        field_list: list[tuple[str, Any]] = []
 
-        some_required_number = (None, str(self.some_required_number).encode(), "text/plain")
+        field_list.append(("some_file", self.some_file.to_tuple()))
 
-        some_object = (None, json.dumps(self.some_object.to_dict()).encode(), "application/json")
+        field_list.append(("some_required_number", (None, str(self.some_required_number).encode(), "text/plain")))
 
-        some_nullable_object: tuple[None, bytes, str]
+        field_list.append(("some_object", (None, json.dumps(self.some_object.to_dict()).encode(), "application/json")))
 
         if isinstance(self.some_nullable_object, BodyUploadFileTestsUploadPostSomeNullableObject):
-            some_nullable_object = (None, json.dumps(self.some_nullable_object.to_dict()).encode(), "application/json")
+            field_list.append(
+                (
+                    "some_nullable_object",
+                    (None, json.dumps(self.some_nullable_object.to_dict()).encode(), "application/json"),
+                )
+            )
         else:
-            some_nullable_object = (None, str(self.some_nullable_object).encode(), "text/plain")
+            field_list.append(("some_nullable_object", (None, str(self.some_nullable_object).encode(), "text/plain")))
 
-        some_optional_file: Union[Unset, FileJsonType] = UNSET
         if not isinstance(self.some_optional_file, Unset):
-            some_optional_file = self.some_optional_file.to_tuple()
+            field_list.append(("some_optional_file", self.some_optional_file.to_tuple()))
 
-        some_string = (
-            self.some_string
-            if isinstance(self.some_string, Unset)
-            else (None, str(self.some_string).encode(), "text/plain")
-        )
+        if not isinstance(self.some_string, Unset):
+            field_list.append(("some_string", (None, str(self.some_string).encode(), "text/plain")))
 
-        a_datetime: Union[Unset, bytes] = UNSET
         if not isinstance(self.a_datetime, Unset):
-            a_datetime = self.a_datetime.isoformat().encode()
+            field_list.append(("a_datetime", self.a_datetime.isoformat().encode()))
 
-        a_date: Union[Unset, bytes] = UNSET
         if not isinstance(self.a_date, Unset):
-            a_date = self.a_date.isoformat().encode()
+            field_list.append(("a_date", self.a_date.isoformat().encode()))
 
-        some_number = (
-            self.some_number
-            if isinstance(self.some_number, Unset)
-            else (None, str(self.some_number).encode(), "text/plain")
-        )
+        if not isinstance(self.some_number, Unset):
+            field_list.append(("some_number", (None, str(self.some_number).encode(), "text/plain")))
 
-        some_nullable_number: Union[Unset, tuple[None, bytes, str]]
+        if not isinstance(self.some_nullable_number, Unset):
+            if isinstance(self.some_nullable_number, float):
+                field_list.append(
+                    ("some_nullable_number", (None, str(self.some_nullable_number).encode(), "text/plain"))
+                )
+            else:
+                field_list.append(
+                    ("some_nullable_number", (None, str(self.some_nullable_number).encode(), "text/plain"))
+                )
 
-        if isinstance(self.some_nullable_number, Unset):
-            some_nullable_number = UNSET
-        elif isinstance(self.some_nullable_number, float):
-            some_nullable_number = (None, str(self.some_nullable_number).encode(), "text/plain")
-        else:
-            some_nullable_number = (None, str(self.some_nullable_number).encode(), "text/plain")
-
-        some_int_array: Union[Unset, tuple[None, bytes, str]] = UNSET
         if not isinstance(self.some_int_array, Unset):
-            _temp_some_int_array = []
-            for some_int_array_item_data in self.some_int_array:
-                some_int_array_item: Union[None, int]
-                some_int_array_item = some_int_array_item_data
-                _temp_some_int_array.append(some_int_array_item)
-            some_int_array = (None, json.dumps(_temp_some_int_array).encode(), "application/json")
+            for some_int_array_item_element in self.some_int_array:
+                if isinstance(some_int_array_item_element, int):
+                    field_list.append(
+                        ("some_int_array", (None, str(some_int_array_item_element).encode(), "text/plain"))
+                    )
+                else:
+                    field_list.append(
+                        ("some_int_array", (None, str(some_int_array_item_element).encode(), "text/plain"))
+                    )
+
+        if not isinstance(self.some_array, Unset):
+            if isinstance(self.some_array, list):
+                for some_array_type_0_item_element in self.some_array:
+                    field_list.append(
+                        (
+                            "some_array",
+                            (None, json.dumps(some_array_type_0_item_element.to_dict()).encode(), "application/json"),
+                        )
+                    )
+            else:
+                field_list.append(("some_array", (None, str(self.some_array).encode(), "text/plain")))
 
-        some_array: Union[Unset, tuple[None, bytes, str]]
-
-        if isinstance(self.some_array, Unset):
-            some_array = UNSET
-        elif isinstance(self.some_array, list):
-            _temp_some_array = []
-            for some_array_type_0_item_data in self.some_array:
-                some_array_type_0_item = some_array_type_0_item_data.to_dict()
-                _temp_some_array.append(some_array_type_0_item)
-            some_array = (None, json.dumps(_temp_some_array).encode(), "application/json")
-        else:
-            some_array = (None, str(self.some_array).encode(), "text/plain")
-
-        some_optional_object: Union[Unset, tuple[None, bytes, str]] = UNSET
         if not isinstance(self.some_optional_object, Unset):
-            some_optional_object = (None, json.dumps(self.some_optional_object.to_dict()).encode(), "application/json")
+            field_list.append(
+                (
+                    "some_optional_object",
+                    (None, json.dumps(self.some_optional_object.to_dict()).encode(), "application/json"),
+                )
+            )
 
-        some_enum: Union[Unset, tuple[None, bytes, str]] = UNSET
         if not isinstance(self.some_enum, Unset):
-            some_enum = (None, str(self.some_enum.value).encode(), "text/plain")
+            field_list.append(("some_enum", (None, str(self.some_enum.value).encode(), "text/plain")))
 
-        field_dict: dict[str, Any] = {}
         for prop_name, prop in self.additional_properties.items():
-            field_dict[prop_name] = (None, json.dumps(prop.to_dict()).encode(), "application/json")
-        field_dict.update(
-            {
-                "some_file": some_file,
-                "some_required_number": some_required_number,
-                "some_object": some_object,
-                "some_nullable_object": some_nullable_object,
-            }
-        )
-        if some_optional_file is not UNSET:
-            field_dict["some_optional_file"] = some_optional_file
-        if some_string is not UNSET:
-            field_dict["some_string"] = some_string
-        if a_datetime is not UNSET:
-            field_dict["a_datetime"] = a_datetime
-        if a_date is not UNSET:
-            field_dict["a_date"] = a_date
-        if some_number is not UNSET:
-            field_dict["some_number"] = some_number
-        if some_nullable_number is not UNSET:
-            field_dict["some_nullable_number"] = some_nullable_number
-        if some_int_array is not UNSET:
-            field_dict["some_int_array"] = some_int_array
-        if some_array is not UNSET:
-            field_dict["some_array"] = some_array
-        if some_optional_object is not UNSET:
-            field_dict["some_optional_object"] = some_optional_object
-        if some_enum is not UNSET:
-            field_dict["some_enum"] = some_enum
+            field_list.append((prop_name, (None, json.dumps(prop.to_dict()).encode(), "application/json")))
 
-        return field_dict
+        return field_list
 
     @classmethod
     def from_dict(cls: type[T], src_dict: Mapping[str, Any]) -> T:

end_to_end_tests/golden-record/my_test_api_client/models/http_validation_error.py

@@ -30,6 +30,7 @@ def to_dict(self) -> dict[str, Any]:
                 detail.append(detail_item)
 
         field_dict: dict[str, Any] = {}
+
         field_dict.update({})
         if detail is not UNSET:
             field_dict["detail"] = detail

end_to_end_tests/golden-record/my_test_api_client/models/model_with_additional_properties_inlined.py

@@ -33,6 +33,7 @@ def to_dict(self) -> dict[str, Any]:
         field_dict: dict[str, Any] = {}
         for prop_name, prop in self.additional_properties.items():
             field_dict[prop_name] = prop.to_dict()
+
         field_dict.update({})
         if a_number is not UNSET:
             field_dict["a_number"] = a_number

end_to_end_tests/golden-record/my_test_api_client/models/model_with_union_property.py

@@ -29,6 +29,7 @@ def to_dict(self) -> dict[str, Any]:
             a_property = self.a_property.value
 
         field_dict: dict[str, Any] = {}
+
         field_dict.update({})
         if a_property is not UNSET:
             field_dict["a_property"] = a_property

end_to_end_tests/golden-record/my_test_api_client/models/model_with_union_property_inlined.py

@@ -34,6 +34,7 @@ def to_dict(self) -> dict[str, Any]:
             fruit = self.fruit.to_dict()
 
         field_dict: dict[str, Any] = {}
+
         field_dict.update({})
         if fruit is not UNSET:
             field_dict["fruit"] = fruit

end_to_end_tests/golden-record/my_test_api_client/models/post_bodies_multiple_files_body.py

@@ -30,18 +30,16 @@ def to_dict(self) -> dict[str, Any]:
 
         return field_dict
 
-    def to_multipart(self) -> dict[str, Any]:
-        a = self.a if isinstance(self.a, Unset) else (None, str(self.a).encode(), "text/plain")
+    def to_multipart(self) -> list[tuple[str, Any]]:
+        field_list: list[tuple[str, Any]] = []
 
-        field_dict: dict[str, Any] = {}
-        for prop_name, prop in self.additional_properties.items():
-            field_dict[prop_name] = (None, str(prop).encode(), "text/plain")
+        if not isinstance(self.a, Unset):
+            field_list.append(("a", (None, str(self.a).encode(), "text/plain")))
 
-        field_dict.update({})
-        if a is not UNSET:
-            field_dict["a"] = a
+        for prop_name, prop in self.additional_properties.items():
+            field_list.append((prop_name, (None, str(prop).encode(), "text/plain")))
 
-        return field_dict
+        return field_list
 
     @classmethod
     def from_dict(cls: type[T], src_dict: Mapping[str, Any]) -> T:

end_to_end_tests/golden-record/my_test_api_client/models/test_inline_objects_body.py

@@ -21,6 +21,7 @@ def to_dict(self) -> dict[str, Any]:
         a_property = self.a_property
 
         field_dict: dict[str, Any] = {}
+
         field_dict.update({})
         if a_property is not UNSET:
             field_dict["a_property"] = a_property

end_to_end_tests/golden-record/my_test_api_client/models/test_inline_objects_response_200.py

@@ -21,6 +21,7 @@ def to_dict(self) -> dict[str, Any]:
         a_property = self.a_property
 
         field_dict: dict[str, Any] = {}
+
         field_dict.update({})
         if a_property is not UNSET:
             field_dict["a_property"] = a_property

end_to_end_tests/golden-record/my_test_api_client/models/validation_error.py

@@ -27,6 +27,7 @@ def to_dict(self) -> dict[str, Any]:
         type_ = self.type_
 
         field_dict: dict[str, Any] = {}
+
         field_dict.update(
             {
                 "loc": loc,

end_to_end_tests/literal-enums-golden-record/my_enum_api_client/models/a_model.py

@@ -52,6 +52,7 @@ def to_dict(self) -> dict[str, Any]:
                 nested_list_of_enums.append(nested_list_of_enums_item)
 
         field_dict: dict[str, Any] = {}
+
         field_dict.update(
             {
                 "an_enum_value": an_enum_value,