feat: Don't generate extra models for allOf of one model BNCH-20256

end_to_end_tests/golden-record-custom/custom_e2e/models/__init__.py

@@ -1,10 +1,6 @@
 """ 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 .an_enum import AnEnum
 from .an_int_enum import AnIntEnum
 from .body_upload_file_tests_upload_post import BodyUploadFileTestsUploadPost

end_to_end_tests/golden-record-custom/custom_e2e/models/a_model.py

@@ -4,10 +4,6 @@
 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.an_enum import AnEnum
 from ..models.different_enum import DifferentEnum
 from ..models.free_form_model import FreeFormModel
@@ -23,18 +19,18 @@ class AModel:
     a_camel_date_time: Union[datetime.datetime, datetime.date]
     a_date: datetime.date
     required_not_nullable: str
-    model: AModelModel
+    model: ModelWithUnionProperty
     one_of_models: Union[FreeFormModel, ModelWithUnionProperty]
     a_nullable_date: Optional[datetime.date]
     required_nullable: Optional[str]
-    nullable_model: Optional[AModelNullableModel]
+    nullable_model: Optional[ModelWithUnionProperty]
     nullable_one_of_models: Union[None, FreeFormModel, ModelWithUnionProperty]
     nested_list_of_enums: Union[Unset, List[List[DifferentEnum]]] = 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_model: Union[Unset, AModelNotRequiredModel] = UNSET
-    not_required_nullable_model: Union[Unset, None, AModelNotRequiredNullableModel] = UNSET
+    not_required_model: Union[Unset, ModelWithUnionProperty] = UNSET
+    not_required_nullable_model: Union[Unset, None, ModelWithUnionProperty] = UNSET
     not_required_one_of_models: Union[Unset, FreeFormModel, ModelWithUnionProperty] = UNSET
     not_required_nullable_one_of_models: Union[Unset, None, FreeFormModel, ModelWithUnionProperty, str] = UNSET
 
@@ -189,7 +185,7 @@ def _parse_a_camel_date_time(data: Union[str]) -> Union[datetime.datetime, datet
 
         required_not_nullable = d.pop("required_not_nullable")
 
-        model = AModelModel.from_dict(d.pop("model"))
+        model = ModelWithUnionProperty.from_dict(d.pop("model"))
 
         def _parse_one_of_models(data: Union[Dict[str, Any]]) -> Union[FreeFormModel, ModelWithUnionProperty]:
             one_of_models: Union[FreeFormModel, ModelWithUnionProperty]
@@ -237,17 +233,17 @@ def _parse_one_of_models(data: Union[Dict[str, Any]]) -> Union[FreeFormModel, Mo
         nullable_model = None
         _nullable_model = d.pop("nullable_model")
         if _nullable_model is not None:
-            nullable_model = AModelNullableModel.from_dict(_nullable_model)
+            nullable_model = ModelWithUnionProperty.from_dict(_nullable_model)
 
-        not_required_model: Union[Unset, AModelNotRequiredModel] = UNSET
+        not_required_model: Union[Unset, ModelWithUnionProperty] = 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 = ModelWithUnionProperty.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 = ModelWithUnionProperty.from_dict(_not_required_nullable_model)
 
         def _parse_nullable_one_of_models(
             data: Union[None, Dict[str, Any]]