Simplify property to multipart code.

Author: dbanty

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

@@ -171,110 +171,83 @@ def to_dict(self) -> dict[str, Any]:
     def to_multipart(self) -> list[tuple[str, Any]]:
         field_list: list[tuple[str, Any]] = []
 
-        some_file = self.some_file.to_tuple()
-        field_list.append(("some_file", some_file))
+        field_list.append(("some_file", self.some_file.to_tuple()))
 
-        some_required_number = (None, str(self.some_required_number).encode(), "text/plain")
-        field_list.append(("some_required_number", some_required_number))
+        field_list.append(("some_required_number", (None, str(self.some_required_number).encode(), "text/plain")))
 
-        some_object = (None, json.dumps(self.some_object.to_dict()).encode(), "application/json")
-        field_list.append(("some_object", some_object))
+        field_list.append(("some_object", (None, json.dumps(self.some_object.to_dict()).encode(), "application/json")))
 
-        some_nullable_object: tuple[None, bytes, str]
         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", some_nullable_object))
+            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()
-        if some_optional_file is not UNSET:
-            field_list.append(("some_optional_file", some_optional_file))
+            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")))
 
-        if some_string is not UNSET:
-            field_list.append(("some_string", some_string))
-
-        a_datetime: Union[Unset, bytes] = UNSET
         if not isinstance(self.a_datetime, Unset):
-            a_datetime = self.a_datetime.isoformat().encode()
-        if a_datetime is not UNSET:
-            field_list.append(("a_datetime", a_datetime))
+            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()
-        if a_date is not UNSET:
-            field_list.append(("a_date", a_date))
+            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 some_number is not UNSET:
-            field_list.append(("some_number", some_number))
-
-        some_nullable_number: Union[Unset, tuple[None, bytes, str]]
-        if isinstance(self.some_nullable_number, Unset):
-            some_nullable_number = UNSET
+        if not isinstance(self.some_number, Unset):
+            field_list.append(("some_number", (None, str(self.some_number).encode(), "text/plain")))
 
-        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")
-        if some_nullable_number is not UNSET:
-            field_list.append(("some_nullable_number", some_nullable_number))
-
-        for some_int_array_element in self.some_int_array or []:
-            some_int_array_item: tuple[None, bytes, str]
-            if isinstance(some_int_array_element, int):
-                some_int_array_item = (None, str(some_int_array_element).encode(), "text/plain")
+        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:
-                some_int_array_item = (None, str(some_int_array_element).encode(), "text/plain")
-            field_list.append(("some_int_array", some_int_array_item))
-
-        some_array: Union[Unset, tuple[None, bytes, str]]
-        if isinstance(self.some_array, Unset):
-            some_array = UNSET
+                field_list.append(
+                    ("some_nullable_number", (None, str(self.some_nullable_number).encode(), "text/plain"))
+                )
 
-        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")
-        if some_array is not UNSET:
-            field_list.append(("some_array", some_array))
+        if not isinstance(self.some_int_array, Unset):
+            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_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")
-        if some_optional_object is not UNSET:
-            field_list.append(("some_optional_object", some_optional_object))
+            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")))
 
-        if some_enum is not UNSET:
-            field_list.append(("some_enum", some_enum))
-
-        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_list += list(field_dict.items())
+            field_list.append((prop_name, (None, json.dumps(prop.to_dict()).encode(), "application/json")))
 
         return field_list
 

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

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

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

@@ -1,4 +1,3 @@
-import json
 from collections.abc import Mapping
 from typing import Any, TypeVar, Union, cast
 
@@ -97,55 +96,61 @@ def to_dict(self) -> dict[str, Any]:
     def to_multipart(self) -> list[tuple[str, Any]]:
         field_list: list[tuple[str, Any]] = []
 
-        for an_enum_value_element in self.an_enum_value or []:
-            an_enum_value_item = (None, str(an_enum_value_element).encode(), "text/plain")
-            field_list.append(("an_enum_value", an_enum_value_item))
-
-        for an_enum_value_with_null_element in self.an_enum_value_with_null or []:
-            an_enum_value_with_null_item: tuple[None, bytes, str]
-            if an_enum_value_with_null_element is None:
-                an_enum_value_with_null_item = (None, str(an_enum_value_with_null_element).encode(), "text/plain")
-            else:
-                an_enum_value_with_null_item = (None, str(an_enum_value_with_null_element).encode(), "text/plain")
-            field_list.append(("an_enum_value_with_null", an_enum_value_with_null_item))
+        if not isinstance(self.an_enum_value, Unset):
+            for an_enum_value_item_element in self.an_enum_value:
+                field_list.append(("an_enum_value", (None, str(an_enum_value_item_element).encode(), "text/plain")))
 
-        for an_enum_value_with_only_null_element in self.an_enum_value_with_only_null or []:
-            an_enum_value_with_only_null_item = (None, str(an_enum_value_with_only_null_element).encode(), "text/plain")
+        if not isinstance(self.an_enum_value_with_null, Unset):
+            for an_enum_value_with_null_item_element in self.an_enum_value_with_null:
+                if an_enum_value_with_null_item_element is None:
+                    field_list.append(
+                        (
+                            "an_enum_value_with_null",
+                            (None, str(an_enum_value_with_null_item_element).encode(), "text/plain"),
+                        )
+                    )
+                else:
+                    field_list.append(
+                        (
+                            "an_enum_value_with_null",
+                            (None, str(an_enum_value_with_null_item_element).encode(), "text/plain"),
+                        )
+                    )
 
-            field_list.append(("an_enum_value_with_only_null", an_enum_value_with_only_null_item))
+        if not isinstance(self.an_enum_value_with_only_null, Unset):
+            for an_enum_value_with_only_null_item_element in self.an_enum_value_with_only_null:
+                field_list.append(
+                    (
+                        "an_enum_value_with_only_null",
+                        (None, str(an_enum_value_with_only_null_item_element).encode(), "text/plain"),
+                    )
+                )
 
-        an_allof_enum_with_overridden_default: Union[Unset, tuple[None, bytes, str]] = UNSET
         if not isinstance(self.an_allof_enum_with_overridden_default, Unset):
-            an_allof_enum_with_overridden_default = (
-                None,
-                str(self.an_allof_enum_with_overridden_default).encode(),
-                "text/plain",
+            field_list.append(
+                (
+                    "an_allof_enum_with_overridden_default",
+                    (None, str(self.an_allof_enum_with_overridden_default).encode(), "text/plain"),
+                )
             )
 
-        if an_allof_enum_with_overridden_default is not UNSET:
-            field_list.append(("an_allof_enum_with_overridden_default", an_allof_enum_with_overridden_default))
-
-        an_optional_allof_enum: Union[Unset, tuple[None, bytes, str]] = UNSET
         if not isinstance(self.an_optional_allof_enum, Unset):
-            an_optional_allof_enum = (None, str(self.an_optional_allof_enum).encode(), "text/plain")
-
-        if an_optional_allof_enum is not UNSET:
-            field_list.append(("an_optional_allof_enum", an_optional_allof_enum))
-
-        for nested_list_of_enums_element in self.nested_list_of_enums or []:
-            _temp_nested_list_of_enums_item = []
-            for nested_list_of_enums_item_item_data in nested_list_of_enums_element:
-                nested_list_of_enums_item_item: str = nested_list_of_enums_item_item_data
-                _temp_nested_list_of_enums_item.append(nested_list_of_enums_item_item)
-            nested_list_of_enums_item = (None, json.dumps(_temp_nested_list_of_enums_item).encode(), "application/json")
+            field_list.append(
+                ("an_optional_allof_enum", (None, str(self.an_optional_allof_enum).encode(), "text/plain"))
+            )
 
-            field_list.append(("nested_list_of_enums", nested_list_of_enums_item))
+        if not isinstance(self.nested_list_of_enums, Unset):
+            for nested_list_of_enums_item_element in self.nested_list_of_enums:
+                for nested_list_of_enums_item_item_element in nested_list_of_enums_item_element:
+                    field_list.append(
+                        (
+                            "nested_list_of_enums",
+                            (None, str(nested_list_of_enums_item_item_element).encode(), "text/plain"),
+                        )
+                    )
 
-        field_dict: dict[str, Any] = {}
         for prop_name, prop in self.additional_properties.items():
-            field_dict[prop_name] = (None, str(prop).encode(), "text/plain")
-
-        field_list += list(field_dict.items())
+            field_list.append((prop_name, (None, str(prop).encode(), "text/plain")))
 
         return field_list
 

integration-tests/integration_tests/models/post_body_multipart_body.py

@@ -48,27 +48,15 @@ def to_dict(self) -> dict[str, Any]:
     def to_multipart(self) -> list[tuple[str, Any]]:
         field_list: list[tuple[str, Any]] = []
 
-        a_string = (None, str(self.a_string).encode(), "text/plain")
+        field_list.append(("a_string", (None, str(self.a_string).encode(), "text/plain")))
 
-        field_list.append(("a_string", a_string))
+        field_list.append(("file", self.file.to_tuple()))
 
-        file = self.file.to_tuple()
-        field_list.append(("file", file))
-
-        description = (
-            self.description
-            if isinstance(self.description, Unset)
-            else (None, str(self.description).encode(), "text/plain")
-        )
+        if not isinstance(self.description, Unset):
+            field_list.append(("description", (None, str(self.description).encode(), "text/plain")))
 
-        if description is not UNSET:
-            field_list.append(("description", description))
-
-        field_dict: dict[str, Any] = {}
         for prop_name, prop in self.additional_properties.items():
-            field_dict[prop_name] = (None, str(prop).encode(), "text/plain")
-
-        field_list += list(field_dict.items())
+            field_list.append((prop_name, (None, str(prop).encode(), "text/plain")))
 
         return field_list