fix: allOf behaviour

Author: Constantinos Symeonides

end_to_end_tests/golden-record/my_test_api_client/api/tests/defaults_tests_defaults_post.py

@@ -27,8 +27,8 @@ def _get_kwargs(
     union_prop: Union[Unset, float, str] = "not a float",
     union_prop_with_ref: Union[AnEnum, Unset, float] = 0.6,
     enum_prop: Union[Unset, AnEnum] = UNSET,
-    model_prop: Union[Unset, ModelWithUnionProperty] = UNSET,
-    required_model_prop: ModelWithUnionProperty,
+    model_prop: Union[Unset, None, ModelWithUnionProperty] = UNSET,
+    required_model_prop: Optional[ModelWithUnionProperty],
     nullable_model_prop: Union[ModelWithUnionProperty, None, Unset] = UNSET,
     nullable_required_model_prop: Union[ModelWithUnionProperty, None],
 ) -> Dict[str, Any]:
@@ -86,11 +86,11 @@ def _get_kwargs(
     if not isinstance(enum_prop, Unset):
         json_enum_prop = enum_prop.value
 
-    json_model_prop: Union[Unset, Dict[str, Any]] = UNSET
+    json_model_prop: Union[Unset, None, Dict[str, Any]] = UNSET
     if not isinstance(model_prop, Unset):
-        json_model_prop = model_prop.to_dict()
+        json_model_prop = model_prop.to_dict() if model_prop else None
 
-    json_required_model_prop = required_model_prop.to_dict()
+    json_required_model_prop = required_model_prop.to_dict() if required_model_prop else None
 
     json_nullable_model_prop: Union[Dict[str, Any], None, Unset]
     if isinstance(nullable_model_prop, Unset):
@@ -100,13 +100,15 @@ def _get_kwargs(
     else:
         json_nullable_model_prop = UNSET
         if not isinstance(nullable_model_prop, Unset):
-            json_nullable_model_prop = nullable_model_prop.to_dict()
+            json_nullable_model_prop = nullable_model_prop.to_dict() if nullable_model_prop else None
 
     json_nullable_required_model_prop: Union[Dict[str, Any], None]
     if nullable_required_model_prop is None:
         json_nullable_required_model_prop = None
     else:
-        json_nullable_required_model_prop = nullable_required_model_prop.to_dict()
+        json_nullable_required_model_prop = (
+            nullable_required_model_prop.to_dict() if nullable_required_model_prop else None
+        )
 
     params: Dict[str, Any] = {
         "string_prop": string_prop,
@@ -125,9 +127,10 @@ def _get_kwargs(
         "nullable_model_prop": json_nullable_model_prop,
         "nullable_required_model_prop": json_nullable_required_model_prop,
     }
-    if not isinstance(json_model_prop, Unset):
+    if not isinstance(json_model_prop, Unset) and json_model_prop is not None:
         params.update(json_model_prop)
-    params.update(json_required_model_prop)
+    if json_required_model_prop is not None:
+        params.update(json_required_model_prop)
     params = {k: v for k, v in params.items() if v is not UNSET and v is not None}
 
     return {
@@ -176,8 +179,8 @@ def sync_detailed(
     union_prop: Union[Unset, float, str] = "not a float",
     union_prop_with_ref: Union[AnEnum, Unset, float] = 0.6,
     enum_prop: Union[Unset, AnEnum] = UNSET,
-    model_prop: Union[Unset, ModelWithUnionProperty] = UNSET,
-    required_model_prop: ModelWithUnionProperty,
+    model_prop: Union[Unset, None, ModelWithUnionProperty] = UNSET,
+    required_model_prop: Optional[ModelWithUnionProperty],
     nullable_model_prop: Union[ModelWithUnionProperty, None, Unset] = UNSET,
     nullable_required_model_prop: Union[ModelWithUnionProperty, None],
 ) -> Response[Union[None, HTTPValidationError]]:
@@ -225,8 +228,8 @@ def sync(
     union_prop: Union[Unset, float, str] = "not a float",
     union_prop_with_ref: Union[AnEnum, Unset, float] = 0.6,
     enum_prop: Union[Unset, AnEnum] = UNSET,
-    model_prop: Union[Unset, ModelWithUnionProperty] = UNSET,
-    required_model_prop: ModelWithUnionProperty,
+    model_prop: Union[Unset, None, ModelWithUnionProperty] = UNSET,
+    required_model_prop: Optional[ModelWithUnionProperty],
     nullable_model_prop: Union[ModelWithUnionProperty, None, Unset] = UNSET,
     nullable_required_model_prop: Union[ModelWithUnionProperty, None],
 ) -> Optional[Union[None, HTTPValidationError]]:
@@ -270,8 +273,8 @@ async def asyncio_detailed(
     union_prop: Union[Unset, float, str] = "not a float",
     union_prop_with_ref: Union[AnEnum, Unset, float] = 0.6,
     enum_prop: Union[Unset, AnEnum] = UNSET,
-    model_prop: Union[Unset, ModelWithUnionProperty] = UNSET,
-    required_model_prop: ModelWithUnionProperty,
+    model_prop: Union[Unset, None, ModelWithUnionProperty] = UNSET,
+    required_model_prop: Optional[ModelWithUnionProperty],
     nullable_model_prop: Union[ModelWithUnionProperty, None, Unset] = UNSET,
     nullable_required_model_prop: Union[ModelWithUnionProperty, None],
 ) -> Response[Union[None, HTTPValidationError]]:
@@ -318,8 +321,8 @@ async def asyncio(
     union_prop: Union[Unset, float, str] = "not a float",
     union_prop_with_ref: Union[AnEnum, Unset, float] = 0.6,
     enum_prop: Union[Unset, AnEnum] = UNSET,
-    model_prop: Union[Unset, ModelWithUnionProperty] = UNSET,
-    required_model_prop: ModelWithUnionProperty,
+    model_prop: Union[Unset, None, ModelWithUnionProperty] = UNSET,
+    required_model_prop: Optional[ModelWithUnionProperty],
     nullable_model_prop: Union[ModelWithUnionProperty, None, Unset] = UNSET,
     nullable_required_model_prop: Union[ModelWithUnionProperty, None],
 ) -> Optional[Union[None, HTTPValidationError]]:

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

@@ -1,11 +1,10 @@
 """ Contains all the data models used in inputs/outputs """
 
 from .a_model import AModel
-from .a_model_model import AModelModel
-from .a_model_not_required_model import AModelNotRequiredModel
-from .a_model_not_required_nullable_model import AModelNotRequiredNullableModel
-from .a_model_nullable_model import AModelNullableModel
+from .a_model_an_all_of_enum import AModelAnAllOfEnum
+from .a_model_model_with_union_property import AModelModelWithUnionProperty
 from .all_of_sub_model import AllOfSubModel
+from .an_all_of_enum import AnAllOfEnum
 from .an_enum import AnEnum
 from .an_int_enum import AnIntEnum
 from .another_all_of_sub_model import AnotherAllOfSubModel

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

@@ -4,10 +4,8 @@
 import attr
 from dateutil.parser import isoparse
 
-from ..models.a_model_model import AModelModel
-from ..models.a_model_not_required_model import AModelNotRequiredModel
-from ..models.a_model_not_required_nullable_model import AModelNotRequiredNullableModel
-from ..models.a_model_nullable_model import AModelNullableModel
+from ..models.a_model_an_all_of_enum import AModelAnAllOfEnum
+from ..models.a_model_model_with_union_property import AModelModelWithUnionProperty
 from ..models.an_enum import AnEnum
 from ..models.different_enum import DifferentEnum
 from ..models.free_form_model import FreeFormModel
@@ -26,24 +24,27 @@ class AModel:
     a_date: datetime.date
     required_not_nullable: str
     one_of_models: Union[FreeFormModel, ModelWithUnionProperty]
-    model: AModelModel
+    model: AModelModelWithUnionProperty
     a_nullable_date: Optional[datetime.date]
     required_nullable: Optional[str]
     nullable_one_of_models: Union[FreeFormModel, ModelWithUnionProperty, None]
-    nullable_model: Optional[AModelNullableModel]
+    nullable_model: Optional[AModelModelWithUnionProperty]
+    an_allof_enum_value: AModelAnAllOfEnum = AModelAnAllOfEnum.OVERRIDDEN_DEFAULT
     nested_list_of_enums: Union[Unset, List[List[DifferentEnum]]] = UNSET
     a_not_required_date: Union[Unset, datetime.date] = UNSET
     attr_1_leading_digit: Union[Unset, str] = UNSET
     not_required_nullable: Union[Unset, None, str] = UNSET
     not_required_not_nullable: Union[Unset, str] = UNSET
     not_required_one_of_models: Union[FreeFormModel, ModelWithUnionProperty, Unset] = UNSET
     not_required_nullable_one_of_models: Union[FreeFormModel, ModelWithUnionProperty, None, Unset, str] = UNSET
-    not_required_model: Union[Unset, AModelNotRequiredModel] = UNSET
-    not_required_nullable_model: Union[Unset, None, AModelNotRequiredNullableModel] = UNSET
+    not_required_model: Union[Unset, AModelModelWithUnionProperty] = UNSET
+    not_required_nullable_model: Union[Unset, None, AModelModelWithUnionProperty] = UNSET
 
     def to_dict(self) -> Dict[str, Any]:
         an_enum_value = self.an_enum_value.value
 
+        an_allof_enum_value = self.an_allof_enum_value.value
+
         if isinstance(self.a_camel_date_time, datetime.datetime):
             a_camel_date_time = self.a_camel_date_time.isoformat()
 
@@ -56,7 +57,7 @@ def to_dict(self) -> Dict[str, Any]:
             one_of_models = self.one_of_models.to_dict()
 
         else:
-            one_of_models = self.one_of_models.to_dict()
+            one_of_models = self.one_of_models.to_dict() if self.one_of_models else None
 
         model = self.model.to_dict()
 
@@ -88,7 +89,7 @@ def to_dict(self) -> Dict[str, Any]:
             nullable_one_of_models = self.nullable_one_of_models.to_dict()
 
         else:
-            nullable_one_of_models = self.nullable_one_of_models.to_dict()
+            nullable_one_of_models = self.nullable_one_of_models.to_dict() if self.nullable_one_of_models else None
 
         not_required_one_of_models: Union[Dict[str, Any], Unset]
         if isinstance(self.not_required_one_of_models, Unset):
@@ -101,7 +102,9 @@ def to_dict(self) -> Dict[str, Any]:
         else:
             not_required_one_of_models = UNSET
             if not isinstance(self.not_required_one_of_models, Unset):
-                not_required_one_of_models = self.not_required_one_of_models.to_dict()
+                not_required_one_of_models = (
+                    self.not_required_one_of_models.to_dict() if self.not_required_one_of_models else None
+                )
 
         not_required_nullable_one_of_models: Union[Dict[str, Any], None, Unset, str]
         if isinstance(self.not_required_nullable_one_of_models, Unset):
@@ -116,7 +119,11 @@ def to_dict(self) -> Dict[str, Any]:
         elif isinstance(self.not_required_nullable_one_of_models, ModelWithUnionProperty):
             not_required_nullable_one_of_models = UNSET
             if not isinstance(self.not_required_nullable_one_of_models, Unset):
-                not_required_nullable_one_of_models = self.not_required_nullable_one_of_models.to_dict()
+                not_required_nullable_one_of_models = (
+                    self.not_required_nullable_one_of_models.to_dict()
+                    if self.not_required_nullable_one_of_models
+                    else None
+                )
 
         else:
             not_required_nullable_one_of_models = self.not_required_nullable_one_of_models
@@ -137,6 +144,7 @@ def to_dict(self) -> Dict[str, Any]:
         field_dict.update(
             {
                 "an_enum_value": an_enum_value,
+                "an_allof_enum_value": an_allof_enum_value,
                 "aCamelDateTime": a_camel_date_time,
                 "a_date": a_date,
                 "required_not_nullable": required_not_nullable,
@@ -174,6 +182,8 @@ def from_dict(cls: Type[T], src_dict: Dict[str, Any]) -> T:
         d = src_dict.copy()
         an_enum_value = AnEnum(d.pop("an_enum_value"))
 
+        an_allof_enum_value = AModelAnAllOfEnum(d.pop("an_allof_enum_value"))
+
         def _parse_a_camel_date_time(data: object) -> Union[datetime.date, datetime.datetime]:
             try:
                 a_camel_date_time_type0: datetime.datetime
@@ -209,14 +219,17 @@ def _parse_one_of_models(data: object) -> Union[FreeFormModel, ModelWithUnionPro
                 pass
             if not isinstance(data, dict):
                 raise TypeError()
-            one_of_models_type1: ModelWithUnionProperty
-            one_of_models_type1 = ModelWithUnionProperty.from_dict(data)
+            one_of_models_type1: Optional[ModelWithUnionProperty]
+            one_of_models_type1 = UNSET
+            _one_of_models_type1 = data
+            if _one_of_models_type1 is not None:
+                one_of_models_type1 = ModelWithUnionProperty.from_dict(_one_of_models_type1)
 
             return one_of_models_type1
 
         one_of_models = _parse_one_of_models(d.pop("one_of_models"))
 
-        model = AModelModel.from_dict(d.pop("model"))
+        model = AModelModelWithUnionProperty.from_dict(d.pop("model"))
 
         nested_list_of_enums = []
         _nested_list_of_enums = d.pop("nested_list_of_enums", UNSET)
@@ -262,8 +275,11 @@ def _parse_nullable_one_of_models(data: object) -> Union[FreeFormModel, ModelWit
                 pass
             if not isinstance(data, dict):
                 raise TypeError()
-            nullable_one_of_models_type1: ModelWithUnionProperty
-            nullable_one_of_models_type1 = ModelWithUnionProperty.from_dict(data)
+            nullable_one_of_models_type1: Optional[ModelWithUnionProperty]
+            nullable_one_of_models_type1 = UNSET
+            _nullable_one_of_models_type1 = data
+            if _nullable_one_of_models_type1 is not None:
+                nullable_one_of_models_type1 = ModelWithUnionProperty.from_dict(_nullable_one_of_models_type1)
 
             return nullable_one_of_models_type1
 
@@ -286,10 +302,12 @@ def _parse_not_required_one_of_models(data: object) -> Union[FreeFormModel, Mode
                 pass
             if not isinstance(data, dict):
                 raise TypeError()
-            not_required_one_of_models_type1: Union[Unset, ModelWithUnionProperty]
+            not_required_one_of_models_type1: Union[Unset, None, ModelWithUnionProperty]
             not_required_one_of_models_type1 = UNSET
             _not_required_one_of_models_type1 = data
-            if not isinstance(_not_required_one_of_models_type1, Unset):
+            if _not_required_one_of_models_type1 is not None and not isinstance(
+                _not_required_one_of_models_type1, Unset
+            ):
                 not_required_one_of_models_type1 = ModelWithUnionProperty.from_dict(_not_required_one_of_models_type1)
 
             return not_required_one_of_models_type1
@@ -318,12 +336,14 @@ def _parse_not_required_nullable_one_of_models(
             except:  # noqa: E722
                 pass
             try:
-                not_required_nullable_one_of_models_type1: Union[Unset, ModelWithUnionProperty]
+                not_required_nullable_one_of_models_type1: Union[Unset, None, ModelWithUnionProperty]
                 if not isinstance(data, dict):
                     raise TypeError()
                 not_required_nullable_one_of_models_type1 = UNSET
                 _not_required_nullable_one_of_models_type1 = data
-                if not isinstance(_not_required_nullable_one_of_models_type1, Unset):
+                if _not_required_nullable_one_of_models_type1 is not None and not isinstance(
+                    _not_required_nullable_one_of_models_type1, Unset
+                ):
                     not_required_nullable_one_of_models_type1 = ModelWithUnionProperty.from_dict(
                         _not_required_nullable_one_of_models_type1
                     )
@@ -340,20 +360,21 @@ def _parse_not_required_nullable_one_of_models(
         nullable_model = None
         _nullable_model = d.pop("nullable_model")
         if _nullable_model is not None:
-            nullable_model = AModelNullableModel.from_dict(_nullable_model)
+            nullable_model = AModelModelWithUnionProperty.from_dict(_nullable_model)
 
-        not_required_model: Union[Unset, AModelNotRequiredModel] = UNSET
+        not_required_model: Union[Unset, AModelModelWithUnionProperty] = UNSET
         _not_required_model = d.pop("not_required_model", UNSET)
         if not isinstance(_not_required_model, Unset):
-            not_required_model = AModelNotRequiredModel.from_dict(_not_required_model)
+            not_required_model = AModelModelWithUnionProperty.from_dict(_not_required_model)
 
         not_required_nullable_model = None
         _not_required_nullable_model = d.pop("not_required_nullable_model", UNSET)
         if _not_required_nullable_model is not None and not isinstance(_not_required_nullable_model, Unset):
-            not_required_nullable_model = AModelNotRequiredNullableModel.from_dict(_not_required_nullable_model)
+            not_required_nullable_model = AModelModelWithUnionProperty.from_dict(_not_required_nullable_model)
 
         a_model = cls(
             an_enum_value=an_enum_value,
+            an_allof_enum_value=an_allof_enum_value,
             a_camel_date_time=a_camel_date_time,
             a_date=a_date,
             required_not_nullable=required_not_nullable,

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

@@ -0,0 +1,11 @@
+from enum import Enum
+
+
+class AModelAnAllOfEnum(str, Enum):
+    FOO = "foo"
+    BAR = "bar"
+    A_DEFAULT = "a_default"
+    OVERRIDDEN_DEFAULT = "overridden_default"
+
+    def __str__(self) -> str:
+        return str(self.value)

end_to_end_tests/golden-record/my_test_api_client/models/a_model_model.py renamed to end_to_end_tests/golden-record/my_test_api_client/models/a_model_model_with_union_property.py

@@ -1,20 +1,19 @@
-from typing import Any, Dict, List, Type, TypeVar, Union
+from typing import Any, Dict, Type, TypeVar, Union
 
 import attr
 
 from ..models.an_enum import AnEnum
 from ..models.an_int_enum import AnIntEnum
 from ..types import UNSET, Unset
 
-T = TypeVar("T", bound="AModelModel")
+T = TypeVar("T", bound="AModelModelWithUnionProperty")
 
 
 @attr.s(auto_attribs=True)
-class AModelModel:
+class AModelModelWithUnionProperty:
     """  """
 
     a_property: Union[AnEnum, AnIntEnum, Unset] = UNSET
-    additional_properties: Dict[str, Any] = attr.ib(init=False, factory=dict)
 
     def to_dict(self) -> Dict[str, Any]:
         a_property: Union[Unset, int, str]
@@ -31,7 +30,6 @@ def to_dict(self) -> Dict[str, Any]:
                 a_property = self.a_property.value
 
         field_dict: Dict[str, Any] = {}
-        field_dict.update(self.additional_properties)
         field_dict.update({})
         if a_property is not UNSET:
             field_dict["a_property"] = a_property
@@ -69,25 +67,8 @@ def _parse_a_property(data: object) -> Union[AnEnum, AnIntEnum, Unset]:
 
         a_property = _parse_a_property(d.pop("a_property", UNSET))
 
-        a_model_model = cls(
+        a_model_model_with_union_property = cls(
             a_property=a_property,
         )
 
-        a_model_model.additional_properties = d
-        return a_model_model
-
-    @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
+        return a_model_model_with_union_property