Improve grouping of each multipart field

Author: dbanty

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

@@ -170,29 +170,29 @@ 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()
 
+        some_file = self.some_file.to_tuple()
         field_list.append(("some_file", some_file))
-        some_required_number = (None, str(self.some_required_number).encode(), "text/plain")
 
+        some_required_number = (None, str(self.some_required_number).encode(), "text/plain")
         field_list.append(("some_required_number", some_required_number))
-        some_object = (None, json.dumps(self.some_object.to_dict()).encode(), "application/json")
 
+        some_object = (None, json.dumps(self.some_object.to_dict()).encode(), "application/json")
         field_list.append(("some_object", some_object))
-        some_nullable_object: tuple[None, bytes, str]
 
+        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")
         else:
             some_nullable_object = (None, str(self.some_nullable_object).encode(), "text/plain")
-
         field_list.append(("some_nullable_object", some_nullable_object))
+
         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))
+
         some_string = (
             self.some_string
             if isinstance(self.some_string, Unset)
@@ -201,18 +201,19 @@ def to_multipart(self) -> list[tuple[str, Any]]:
 
         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))
+
         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))
+
         some_number = (
             self.some_number
             if isinstance(self.some_number, Unset)
@@ -221,31 +222,30 @@ def to_multipart(self) -> list[tuple[str, Any]]:
 
         if some_number is not UNSET:
             field_list.append(("some_number", some_number))
-        some_nullable_number: Union[Unset, tuple[None, bytes, str]]
 
+        some_nullable_number: Union[Unset, tuple[None, bytes, str]]
         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")
-
         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")
             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
+
         elif isinstance(self.some_array, list):
             _temp_some_array = []
             for some_array_type_0_item_data in self.some_array:
@@ -254,15 +254,15 @@ def to_multipart(self) -> list[tuple[str, Any]]:
             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))
+
         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))
+
         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")

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

@@ -32,6 +32,7 @@ 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 a is not UNSET:

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

@@ -96,19 +96,17 @@ 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))
 
         for an_enum_value_with_only_null_element in self.an_enum_value_with_only_null or []:
@@ -126,12 +124,14 @@ def to_multipart(self) -> list[tuple[str, Any]]:
 
         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:

integration-tests/integration_tests/models/post_body_multipart_body.py

@@ -47,12 +47,14 @@ 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", a_string))
-        file = self.file.to_tuple()
 
+        file = self.file.to_tuple()
         field_list.append(("file", file))
+
         description = (
             self.description
             if isinstance(self.description, Unset)

openapi_python_client/templates/model.py.jinja

@@ -84,14 +84,13 @@ class {{ class_name }}:
 
 {% macro _transform_property(property, content, multipart=False) %}
 {% import "property_templates/" + property.template as prop_template %}
-{% if multipart %}
+{%- if multipart -%}
 {{ prop_template.transform_multipart(property, content, property.python_name) }}
-{% elif prop_template.transform %}
+{%- elif prop_template.transform -%}
 {{ prop_template.transform(property=property, source=content, destination=property.python_name) }}
-{% else %}
+{%- else -%}
 {{ property.python_name }} = {{ content }}
-{% endif %}
-
+{%- endif -%}
 {% endmacro %}
 
 {% macro _prepare_field_dict(multipart=False) %}
@@ -113,6 +112,7 @@ field_dict.update(self.additional_properties)
 {% macro _to_dict() %}
 {% for property in model.required_properties + model.optional_properties -%}
 {{ _transform_property(property, "self." + property.python_name) }}
+
 {% endfor %}
 
 {{ _prepare_field_dict() }}
@@ -144,6 +144,7 @@ return field_dict
 {% if model.is_multipart_body %}
     def to_multipart(self) -> list[tuple[str, Any]]:
         field_list: list[tuple[str, Any]] = []
+
         {% for property in model.required_properties + model.optional_properties %}
         {% if property.__class__.__name__ == 'ListProperty' %}
         {% if not property.required %}
@@ -163,6 +164,7 @@ return field_dict
         field_list.append(("{{ property.python_name }}", {{property.python_name}}))
         {% endif %}
         {% endif %}
+
         {% endfor %}
 
         {{ _prepare_field_dict(True) | indent(8) }}

openapi_python_client/templates/property_templates/file_property.py.jinja

@@ -25,9 +25,9 @@ if not isinstance({{ source }}, Unset):
 {% macro transform_multipart(property, source, destination) %}
 {% if property.required %}
 {{ destination }} = {{ source }}.to_tuple()
-{% else %}
+{%- else %}
 {{ destination }}: {{ property.get_type_string(json=True) }} = UNSET
 if not isinstance({{ source }}, Unset):
     {{ destination }} = {{ source }}.to_tuple()
-{% endif %}
+{%- endif -%}
 {% endmacro %}

openapi_python_client/templates/property_templates/float_property.py.jinja

@@ -7,5 +7,5 @@ str({{ source }})
 {{ destination }} = {{source}} if isinstance({{source}}, Unset) else (None, str({{source}}).encode(), "text/plain")
 {% else %}
 {{ destination }} =  (None, str({{ source }}).encode(), "text/plain")
-{% endif %}
+{%- endif -%}
 {% endmacro %}

openapi_python_client/templates/property_templates/union_property.py.jinja

@@ -86,7 +86,6 @@ if isinstance({{ source }}, {{ inner_property.get_instance_type_string() }}):
 {% macro transform_multipart(property, source, destination) %}
 {% set ns = namespace(has_if = false) %}
 {{ destination }}: {{ property.get_type_string(json=False, multipart=True) }}
-
 {% if not property.required %}
 if isinstance({{ source }}, Unset):
     {{ destination }} = UNSET
@@ -97,11 +96,13 @@ if isinstance({{ source }}, Unset):
 {{ instance_check(inner_property, source) }}
 {% set ns.has_if = true %}
 {% elif not loop.last %}
+
 el{{ instance_check(inner_property, source) }}
 {% else %}
+
 else:
 {% endif %}
 {% import "property_templates/" + inner_property.template as inner_template %}
     {{ inner_template.transform_multipart(inner_property, source, destination) | indent(4) | trim }}
-{% endfor %}
+{%- endfor -%}
 {% endmacro %}