Merge branch 'main' into 342-could-not-find-reference-in-parsed-models,-when-components-title-is-different-from-the-name

Author: dbanty

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, ModelWithUnionProperty] = UNSET,
+    nullable_required_model_prop: 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, Dict[str, Any]] = UNSET
+    if not isinstance(nullable_model_prop, Unset):
+        json_nullable_model_prop = nullable_model_prop.to_dict()
 
-    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()
 
     params: Dict[str, Any] = {
         "string_prop": string_prop,
@@ -122,12 +112,13 @@ 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):
+        params.update(json_nullable_model_prop)
+    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 +169,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, ModelWithUnionProperty] = UNSET,
+    nullable_required_model_prop: ModelWithUnionProperty,
 ) -> Response[Union[None, HTTPValidationError]]:
     kwargs = _get_kwargs(
         client=client,
@@ -227,8 +218,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, ModelWithUnionProperty] = UNSET,
+    nullable_required_model_prop: ModelWithUnionProperty,
 ) -> Optional[Union[None, HTTPValidationError]]:
     """  """
 
@@ -272,8 +263,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, ModelWithUnionProperty] = UNSET,
+    nullable_required_model_prop: ModelWithUnionProperty,
 ) -> Response[Union[None, HTTPValidationError]]:
     kwargs = _get_kwargs(
         client=client,
@@ -320,8 +311,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, ModelWithUnionProperty] = UNSET,
+    nullable_required_model_prop: 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
+    nullable_model: ModelWithUnionProperty
     a_nullable_date: Optional[datetime.date]
     required_nullable: Optional[str]
     nullable_one_of_models: Union[FreeFormModel, ModelWithUnionProperty, None]
-    nullable_model: Optional[AModelNullableModel]
     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, ModelWithUnionProperty] = UNSET
 
     def to_dict(self) -> Dict[str, Any]:
         an_enum_value = self.an_enum_value.value
@@ -60,6 +56,8 @@ def to_dict(self) -> Dict[str, Any]:
 
         model = self.model.to_dict()
 
+        nullable_model = self.nullable_model.to_dict()
+
         nested_list_of_enums: Union[Unset, List[List[str]]] = UNSET
         if not isinstance(self.nested_list_of_enums, Unset):
             nested_list_of_enums = []
@@ -121,17 +119,13 @@ def to_dict(self) -> Dict[str, Any]:
         else:
             not_required_nullable_one_of_models = self.not_required_nullable_one_of_models
 
-        nullable_model = self.nullable_model.to_dict() if self.nullable_model else None
-
         not_required_model: Union[Unset, Dict[str, Any]] = UNSET
         if not isinstance(self.not_required_model, Unset):
             not_required_model = self.not_required_model.to_dict()
 
-        not_required_nullable_model: Union[Unset, None, Dict[str, Any]] = UNSET
+        not_required_nullable_model: Union[Unset, Dict[str, Any]] = UNSET
         if not isinstance(self.not_required_nullable_model, Unset):
-            not_required_nullable_model = (
-                self.not_required_nullable_model.to_dict() if self.not_required_nullable_model else None
-            )
+            not_required_nullable_model = self.not_required_nullable_model.to_dict()
 
         field_dict: Dict[str, Any] = {}
         field_dict.update(
@@ -142,10 +136,10 @@ def to_dict(self) -> Dict[str, Any]:
                 "required_not_nullable": required_not_nullable,
                 "one_of_models": one_of_models,
                 "model": model,
+                "nullable_model": nullable_model,
                 "a_nullable_date": a_nullable_date,
                 "required_nullable": required_nullable,
                 "nullable_one_of_models": nullable_one_of_models,
-                "nullable_model": nullable_model,
             }
         )
         if nested_list_of_enums is not UNSET:
@@ -216,7 +210,9 @@ 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"))
+
+        nullable_model = ModelWithUnionProperty.from_dict(d.pop("nullable_model"))
 
         nested_list_of_enums = []
         _nested_list_of_enums = d.pop("nested_list_of_enums", UNSET)
@@ -337,20 +333,15 @@ def _parse_not_required_nullable_one_of_models(
             d.pop("not_required_nullable_one_of_models", UNSET)
         )
 
-        nullable_model = None
-        _nullable_model = d.pop("nullable_model")
-        if _nullable_model is not None:
-            nullable_model = AModelNullableModel.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: Union[Unset, ModelWithUnionProperty] = UNSET
         _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)
+        if not isinstance(_not_required_nullable_model, Unset):
+            not_required_nullable_model = ModelWithUnionProperty.from_dict(_not_required_nullable_model)
 
         a_model = cls(
             an_enum_value=an_enum_value,
@@ -359,6 +350,7 @@ def _parse_not_required_nullable_one_of_models(
             required_not_nullable=required_not_nullable,
             one_of_models=one_of_models,
             model=model,
+            nullable_model=nullable_model,
             nested_list_of_enums=nested_list_of_enums,
             a_nullable_date=a_nullable_date,
             a_not_required_date=a_not_required_date,
@@ -369,7 +361,6 @@ def _parse_not_required_nullable_one_of_models(
             nullable_one_of_models=nullable_one_of_models,
             not_required_one_of_models=not_required_one_of_models,
             not_required_nullable_one_of_models=not_required_nullable_one_of_models,
-            nullable_model=nullable_model,
             not_required_model=not_required_model,
             not_required_nullable_model=not_required_nullable_model,
         )