fix: Non-JSON non-file multipart props need to be text/plain

Author: Constantinos Symeonides

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

@@ -8,6 +8,7 @@
 from .an_int_enum import AnIntEnum
 from .another_all_of_sub_model import AnotherAllOfSubModel
 from .body_upload_file_tests_upload_post import BodyUploadFileTestsUploadPost
+from .body_upload_file_tests_upload_post_additional_property import BodyUploadFileTestsUploadPostAdditionalProperty
 from .body_upload_file_tests_upload_post_some_nullable_object import BodyUploadFileTestsUploadPostSomeNullableObject
 from .body_upload_file_tests_upload_post_some_object import BodyUploadFileTestsUploadPostSomeObject
 from .body_upload_file_tests_upload_post_some_optional_object import BodyUploadFileTestsUploadPostSomeOptionalObject

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

@@ -4,13 +4,17 @@
 
 import attr
 
+from ..models.body_upload_file_tests_upload_post_additional_property import (
+    BodyUploadFileTestsUploadPostAdditionalProperty,
+)
 from ..models.body_upload_file_tests_upload_post_some_nullable_object import (
     BodyUploadFileTestsUploadPostSomeNullableObject,
 )
 from ..models.body_upload_file_tests_upload_post_some_object import BodyUploadFileTestsUploadPostSomeObject
 from ..models.body_upload_file_tests_upload_post_some_optional_object import (
     BodyUploadFileTestsUploadPostSomeOptionalObject,
 )
+from ..models.different_enum import DifferentEnum
 from ..types import UNSET, File, FileJsonType, Unset
 
 T = TypeVar("T", bound="BodyUploadFileTestsUploadPost")
@@ -28,6 +32,10 @@ class BodyUploadFileTestsUploadPost:
     some_number: Union[Unset, float] = UNSET
     some_array: Union[Unset, List[float]] = UNSET
     some_optional_object: Union[Unset, BodyUploadFileTestsUploadPostSomeOptionalObject] = UNSET
+    some_enum: Union[Unset, DifferentEnum] = UNSET
+    additional_properties: Dict[str, BodyUploadFileTestsUploadPostAdditionalProperty] = attr.ib(
+        init=False, factory=dict
+    )
 
     def to_dict(self) -> Dict[str, Any]:
         some_file = self.some_file.to_tuple()
@@ -50,7 +58,14 @@ def to_dict(self) -> Dict[str, Any]:
 
         some_nullable_object = self.some_nullable_object.to_dict() if self.some_nullable_object else None
 
+        some_enum: Union[Unset, str] = UNSET
+        if not isinstance(self.some_enum, Unset):
+            some_enum = self.some_enum.value
+
         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,
@@ -68,6 +83,8 @@ def to_dict(self) -> Dict[str, Any]:
             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
 
         return field_dict
 
@@ -80,8 +97,8 @@ def to_multipart(self) -> Dict[str, Any]:
         if not isinstance(self.some_optional_file, Unset):
             some_optional_file = self.some_optional_file.to_tuple()
 
-        some_string = self.some_string
-        some_number = self.some_number
+        some_string = self.some_string if self.some_string is UNSET else (None, self.some_string, "text/plain")
+        some_number = self.some_number if self.some_number is UNSET else (None, self.some_number, "text/plain")
         some_array: Union[Unset, Tuple[None, str, str]] = UNSET
         if not isinstance(self.some_array, Unset):
             _temp_some_array = self.some_array
@@ -97,7 +114,14 @@ def to_multipart(self) -> Dict[str, Any]:
             else None
         )
 
+        some_enum: Union[Unset, Tuple[None, str, str]] = UNSET
+        if not isinstance(self.some_enum, Unset):
+            some_enum = (None, str(self.some_enum.value), "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()), "application/json")
+
         field_dict.update(
             {
                 "some_file": some_file,
@@ -115,6 +139,8 @@ def to_multipart(self) -> Dict[str, Any]:
             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
 
         return field_dict
 
@@ -152,6 +178,13 @@ def from_dict(cls: Type[T], src_dict: Dict[str, Any]) -> T:
         else:
             some_nullable_object = BodyUploadFileTestsUploadPostSomeNullableObject.from_dict(_some_nullable_object)
 
+        _some_enum = d.pop("some_enum", UNSET)
+        some_enum: Union[Unset, DifferentEnum]
+        if isinstance(_some_enum, Unset):
+            some_enum = UNSET
+        else:
+            some_enum = DifferentEnum(_some_enum)
+
         body_upload_file_tests_upload_post = cls(
             some_file=some_file,
             some_object=some_object,
@@ -161,6 +194,30 @@ def from_dict(cls: Type[T], src_dict: Dict[str, Any]) -> T:
             some_array=some_array,
             some_optional_object=some_optional_object,
             some_nullable_object=some_nullable_object,
+            some_enum=some_enum,
         )
 
+        additional_properties = {}
+        for prop_name, prop_dict in d.items():
+            additional_property = BodyUploadFileTestsUploadPostAdditionalProperty.from_dict(prop_dict)
+
+            additional_properties[prop_name] = additional_property
+
+        body_upload_file_tests_upload_post.additional_properties = additional_properties
         return body_upload_file_tests_upload_post
+
+    @property
+    def additional_keys(self) -> List[str]:
+        return list(self.additional_properties.keys())
+
+    def __getitem__(self, key: str) -> BodyUploadFileTestsUploadPostAdditionalProperty:
+        return self.additional_properties[key]
+
+    def __setitem__(self, key: str, value: BodyUploadFileTestsUploadPostAdditionalProperty) -> None:
+        self.additional_properties[key] = value
+
+    def __delitem__(self, key: str) -> None:
+        del self.additional_properties[key]
+
+    def __contains__(self, key: str) -> bool:
+        return key in self.additional_properties

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

@@ -0,0 +1,54 @@
+from typing import Any, Dict, List, Type, TypeVar, Union
+
+import attr
+
+from ..types import UNSET, Unset
+
+T = TypeVar("T", bound="BodyUploadFileTestsUploadPostAdditionalProperty")
+
+
+@attr.s(auto_attribs=True)
+class BodyUploadFileTestsUploadPostAdditionalProperty:
+    """ """
+
+    foo: Union[Unset, str] = UNSET
+    additional_properties: Dict[str, Any] = attr.ib(init=False, factory=dict)
+
+    def to_dict(self) -> Dict[str, Any]:
+        foo = self.foo
+
+        field_dict: Dict[str, Any] = {}
+        field_dict.update(self.additional_properties)
+        field_dict.update({})
+        if foo is not UNSET:
+            field_dict["foo"] = foo
+
+        return field_dict
+
+    @classmethod
+    def from_dict(cls: Type[T], src_dict: Dict[str, Any]) -> T:
+        d = src_dict.copy()
+        foo = d.pop("foo", UNSET)
+
+        body_upload_file_tests_upload_post_additional_property = cls(
+            foo=foo,
+        )
+
+        body_upload_file_tests_upload_post_additional_property.additional_properties = d
+        return body_upload_file_tests_upload_post_additional_property
+
+    @property
+    def additional_keys(self) -> List[str]:
+        return list(self.additional_properties.keys())
+
+    def __getitem__(self, key: str) -> Any:
+        return self.additional_properties[key]
+
+    def __setitem__(self, key: str, value: Any) -> None:
+        self.additional_properties[key] = value
+
+    def __delitem__(self, key: str) -> None:
+        del self.additional_properties[key]
+
+    def __contains__(self, key: str) -> bool:
+        return key in self.additional_properties

end_to_end_tests/openapi.json

@@ -1070,9 +1070,19 @@
                 "type": "string"
               }
             }
+          },
+          "some_enum": {
+            "$ref": "#/components/schemas/DifferentEnum"
           }
         },
-        "additionalProperties": false
+        "additionalProperties": {
+          "type": "object",
+          "properties": {
+            "foo": {
+              "type": "string"
+            }
+          }
+        }
       },
       "DifferentEnum": {
         "title": "DifferentEnum",

openapi_python_client/templates/model.py.jinja

@@ -48,6 +48,8 @@ class {{ class_name }}:
 {% if property.template %}
 {% from "property_templates/" + property.template import transform %}
 {{ transform(property, "self." + property.python_name, property.python_name, stringify=multipart) }}
+{% elif multipart %}
+{{ property.python_name }} = self.{{ property.python_name }} if self.{{ property.python_name }} is UNSET else (None, self.{{ property.python_name }}, "text/plain")
 {% else %}
 {{ property.python_name }} = self.{{ property.python_name }}
 {% endif %}
@@ -59,6 +61,11 @@ field_dict: Dict[str, Any] = {}
 {% from "property_templates/" + model.additional_properties.template import transform %}
 for prop_name, prop in self.additional_properties.items():
     {{ transform(model.additional_properties, "prop", "field_dict[prop_name]", stringify=multipart) | indent(4) }}
+{% elif multipart %}
+field_dict.update({
+    key: (None, value, "text/plain")
+    for key, value in self.additional_properties.items()
+})
 {% else %}
 field_dict.update(self.additional_properties)
 {% endif %}

openapi_python_client/templates/property_templates/enum_property.py.jinja

@@ -11,19 +11,25 @@
 {% macro check_type_for_construct(property, source) %}isinstance({{ source }}, {{ property.value_type.__name__ }}){% endmacro %}
 
 {% macro transform(property, source, destination, declare_type=True, stringify=False) %}
+{% set transformed = source + ".value" %}
+{% set type_string = property.get_type_string(json=True) %}
+{% if stringify %}
+    {% set transformed = "(None, str(" + transformed + "), 'text/plain')" %}
+    {% set type_string = "Union[Unset, Tuple[None, str, str]]" %}
+{% endif %}
 {% if property.required %}
 {% if property.nullable %}
-{{ destination }} = {{ source }}.value if {{ source }} else None
+{{ destination }} = {{ transformed }} if {{ source }} else None
 {% else %}
-{{ destination }} = {{ source }}.value
+{{ destination }} = {{ transformed }}
 {% endif %}
 {% else %}
-{{ destination }}{% if declare_type %}: {{ property.get_type_string(json=True) }}{% endif %} = UNSET
+{{ destination }}{% if declare_type %}: {{ type_string }}{% endif %} = UNSET
 if not isinstance({{ source }}, Unset):
 {% if property.nullable %}
-    {{ destination }} = {{ source }}.value if {{ source }} else None
+    {{ destination }} = {{ transformed }} if {{ source }} else None
 {% else %}
-    {{ destination }} = {{ source }}.value
+    {{ destination }} = {{ transformed }}
 {% endif %}
 {% endif %}
 {% endmacro %}