fix!: If a schema references exactly one other schema in allOf, oneOf, or anyOf that referenced generated model will be used directly instead of generating a copy with another name. (#361)

Author: forest-benchling

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

@@ -29,8 +29,8 @@ def _get_kwargs(
     enum_prop: Union[Unset, AnEnum] = UNSET,
     model_prop: Union[Unset, ModelWithUnionProperty] = UNSET,
     required_model_prop: ModelWithUnionProperty,
-    nullable_model_prop: Union[ModelWithUnionProperty, None, Unset] = UNSET,
-    nullable_required_model_prop: Union[ModelWithUnionProperty, None],
+    nullable_model_prop: Union[Unset, None, ModelWithUnionProperty] = UNSET,
+    nullable_required_model_prop: Optional[ModelWithUnionProperty],
 ) -> Dict[str, Any]:
     url = "{}/tests/defaults".format(client.base_url)
 
@@ -92,21 +92,11 @@ def _get_kwargs(
 
     json_required_model_prop = required_model_prop.to_dict()
 
-    json_nullable_model_prop: Union[Dict[str, Any], None, Unset]
-    if isinstance(nullable_model_prop, Unset):
-        json_nullable_model_prop = UNSET
-    elif nullable_model_prop is None:
-        json_nullable_model_prop = None
-    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: Union[Unset, None, Dict[str, Any]] = UNSET
+    if not isinstance(nullable_model_prop, Unset):
+        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,
@@ -122,12 +112,14 @@ def _get_kwargs(
         "union_prop": json_union_prop,
         "union_prop_with_ref": json_union_prop_with_ref,
         "enum_prop": json_enum_prop,
-        "nullable_model_prop": json_nullable_model_prop,
-        "nullable_required_model_prop": json_nullable_required_model_prop,
     }
     if not isinstance(json_model_prop, Unset):
         params.update(json_model_prop)
     params.update(json_required_model_prop)
+    if not isinstance(json_nullable_model_prop, Unset) and json_nullable_model_prop is not None:
+        params.update(json_nullable_model_prop)
+    if json_nullable_required_model_prop is not None:
+        params.update(json_nullable_required_model_prop)
     params = {k: v for k, v in params.items() if v is not UNSET and v is not None}
 
     return {
@@ -178,8 +170,8 @@ def sync_detailed(
     enum_prop: Union[Unset, AnEnum] = UNSET,
     model_prop: Union[Unset, ModelWithUnionProperty] = UNSET,
     required_model_prop: ModelWithUnionProperty,
-    nullable_model_prop: Union[ModelWithUnionProperty, None, Unset] = UNSET,
-    nullable_required_model_prop: Union[ModelWithUnionProperty, None],
+    nullable_model_prop: Union[Unset, None, ModelWithUnionProperty] = UNSET,
+    nullable_required_model_prop: Optional[ModelWithUnionProperty],
 ) -> Response[Union[None, HTTPValidationError]]:
     kwargs = _get_kwargs(
         client=client,
@@ -227,8 +219,8 @@ def sync(
     enum_prop: Union[Unset, AnEnum] = UNSET,
     model_prop: Union[Unset, ModelWithUnionProperty] = UNSET,
     required_model_prop: ModelWithUnionProperty,
-    nullable_model_prop: Union[ModelWithUnionProperty, None, Unset] = UNSET,
-    nullable_required_model_prop: Union[ModelWithUnionProperty, None],
+    nullable_model_prop: Union[Unset, None, ModelWithUnionProperty] = UNSET,
+    nullable_required_model_prop: Optional[ModelWithUnionProperty],
 ) -> Optional[Union[None, HTTPValidationError]]:
     """  """
 
@@ -272,8 +264,8 @@ async def asyncio_detailed(
     enum_prop: Union[Unset, AnEnum] = UNSET,
     model_prop: Union[Unset, ModelWithUnionProperty] = UNSET,
     required_model_prop: ModelWithUnionProperty,
-    nullable_model_prop: Union[ModelWithUnionProperty, None, Unset] = UNSET,
-    nullable_required_model_prop: Union[ModelWithUnionProperty, None],
+    nullable_model_prop: Union[Unset, None, ModelWithUnionProperty] = UNSET,
+    nullable_required_model_prop: Optional[ModelWithUnionProperty],
 ) -> Response[Union[None, HTTPValidationError]]:
     kwargs = _get_kwargs(
         client=client,
@@ -320,8 +312,8 @@ async def asyncio(
     enum_prop: Union[Unset, AnEnum] = UNSET,
     model_prop: Union[Unset, ModelWithUnionProperty] = UNSET,
     required_model_prop: ModelWithUnionProperty,
-    nullable_model_prop: Union[ModelWithUnionProperty, None, Unset] = UNSET,
-    nullable_required_model_prop: Union[ModelWithUnionProperty, None],
+    nullable_model_prop: Union[Unset, None, ModelWithUnionProperty] = UNSET,
+    nullable_required_model_prop: Optional[ModelWithUnionProperty],
 ) -> Optional[Union[None, HTTPValidationError]]:
     """  """
 

end_to_end_tests/golden-record/my_test_api_client/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 .all_of_sub_model import AllOfSubModel
 from .an_enum import AnEnum
 from .an_int_enum import AnIntEnum

end_to_end_tests/golden-record/my_test_api_client/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
@@ -26,20 +22,20 @@ class AModel:
     a_date: datetime.date
     required_not_nullable: str
     one_of_models: Union[FreeFormModel, ModelWithUnionProperty]
-    model: AModelModel
+    model: ModelWithUnionProperty
     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[ModelWithUnionProperty]
     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, ModelWithUnionProperty] = UNSET
+    not_required_nullable_model: Union[Unset, None, ModelWithUnionProperty] = UNSET
 
     def to_dict(self) -> Dict[str, Any]:
         an_enum_value = self.an_enum_value.value
@@ -216,7 +212,7 @@ def _parse_one_of_models(data: object) -> Union[FreeFormModel, ModelWithUnionPro
 
         one_of_models = _parse_one_of_models(d.pop("one_of_models"))
 
-        model = AModelModel.from_dict(d.pop("model"))
+        model = ModelWithUnionProperty.from_dict(d.pop("model"))
 
         nested_list_of_enums = []
         _nested_list_of_enums = d.pop("nested_list_of_enums", UNSET)
@@ -340,17 +336,17 @@ 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 = 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)
 
         a_model = cls(
             an_enum_value=an_enum_value,