Regenerate golden records

Author: ramnes

Diff for: end_to_end_tests/golden-record/my_test_api_client/models/a_model.py

@@ -209,20 +209,20 @@ def _parse_a_camel_date_time(data: object) -> Union[datetime.date, datetime.date
 
         def _parse_one_of_models(data: object) -> Union[FreeFormModel, ModelWithUnionProperty]:
             try:
-                one_of_models_type_0: FreeFormModel
+                one_of_models_type0: FreeFormModel
                 if not isinstance(data, dict):
                     raise TypeError()
-                one_of_models_type_0 = FreeFormModel.from_dict(data)
+                one_of_models_type0 = FreeFormModel.from_dict(data)
 
-                return one_of_models_type_0
+                return one_of_models_type0
             except:  # noqa: E722
                 pass
             if not isinstance(data, dict):
                 raise TypeError()
-            one_of_models_type_1: ModelWithUnionProperty
-            one_of_models_type_1 = ModelWithUnionProperty.from_dict(data)
+            one_of_models_type1: ModelWithUnionProperty
+            one_of_models_type1 = ModelWithUnionProperty.from_dict(data)
 
-            return one_of_models_type_1
+            return one_of_models_type1
 
         one_of_models = _parse_one_of_models(d.pop("one_of_models"))
 
@@ -267,47 +267,47 @@ def _parse_nullable_one_of_models(data: object) -> Union[FreeFormModel, ModelWit
             if data is None:
                 return data
             try:
-                nullable_one_of_models_type_0: FreeFormModel
+                nullable_one_of_models_type0: FreeFormModel
                 if not isinstance(data, dict):
                     raise TypeError()
-                nullable_one_of_models_type_0 = FreeFormModel.from_dict(data)
+                nullable_one_of_models_type0 = FreeFormModel.from_dict(data)
 
-                return nullable_one_of_models_type_0
+                return nullable_one_of_models_type0
             except:  # noqa: E722
                 pass
             if not isinstance(data, dict):
                 raise TypeError()
-            nullable_one_of_models_type_1: ModelWithUnionProperty
-            nullable_one_of_models_type_1 = ModelWithUnionProperty.from_dict(data)
+            nullable_one_of_models_type1: ModelWithUnionProperty
+            nullable_one_of_models_type1 = ModelWithUnionProperty.from_dict(data)
 
-            return nullable_one_of_models_type_1
+            return nullable_one_of_models_type1
 
         nullable_one_of_models = _parse_nullable_one_of_models(d.pop("nullable_one_of_models"))
 
         def _parse_not_required_one_of_models(data: object) -> Union[FreeFormModel, ModelWithUnionProperty, Unset]:
             if isinstance(data, Unset):
                 return data
             try:
-                not_required_one_of_models_type_0: Union[Unset, FreeFormModel]
+                not_required_one_of_models_type0: Union[Unset, FreeFormModel]
                 if not isinstance(data, dict):
                     raise TypeError()
-                not_required_one_of_models_type_0 = UNSET
-                _not_required_one_of_models_type_0 = data
-                if not isinstance(_not_required_one_of_models_type_0, Unset):
-                    not_required_one_of_models_type_0 = FreeFormModel.from_dict(_not_required_one_of_models_type_0)
+                not_required_one_of_models_type0 = UNSET
+                _not_required_one_of_models_type0 = data
+                if not isinstance(_not_required_one_of_models_type0, Unset):
+                    not_required_one_of_models_type0 = FreeFormModel.from_dict(_not_required_one_of_models_type0)
 
-                return not_required_one_of_models_type_0
+                return not_required_one_of_models_type0
             except:  # noqa: E722
                 pass
             if not isinstance(data, dict):
                 raise TypeError()
-            not_required_one_of_models_type_1: Union[Unset, ModelWithUnionProperty]
-            not_required_one_of_models_type_1 = UNSET
-            _not_required_one_of_models_type_1 = data
-            if not isinstance(_not_required_one_of_models_type_1, Unset):
-                not_required_one_of_models_type_1 = ModelWithUnionProperty.from_dict(_not_required_one_of_models_type_1)
+            not_required_one_of_models_type1: Union[Unset, 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):
+                not_required_one_of_models_type1 = ModelWithUnionProperty.from_dict(_not_required_one_of_models_type1)
 
-            return not_required_one_of_models_type_1
+            return not_required_one_of_models_type1
 
         not_required_one_of_models = _parse_not_required_one_of_models(d.pop("not_required_one_of_models", UNSET))
 
@@ -319,31 +319,31 @@ def _parse_not_required_nullable_one_of_models(
             if isinstance(data, Unset):
                 return data
             try:
-                not_required_nullable_one_of_models_type_0: Union[Unset, FreeFormModel]
+                not_required_nullable_one_of_models_type0: Union[Unset, FreeFormModel]
                 if not isinstance(data, dict):
                     raise TypeError()
-                not_required_nullable_one_of_models_type_0 = UNSET
-                _not_required_nullable_one_of_models_type_0 = data
-                if not isinstance(_not_required_nullable_one_of_models_type_0, Unset):
-                    not_required_nullable_one_of_models_type_0 = FreeFormModel.from_dict(
-                        _not_required_nullable_one_of_models_type_0
+                not_required_nullable_one_of_models_type0 = UNSET
+                _not_required_nullable_one_of_models_type0 = data
+                if not isinstance(_not_required_nullable_one_of_models_type0, Unset):
+                    not_required_nullable_one_of_models_type0 = FreeFormModel.from_dict(
+                        _not_required_nullable_one_of_models_type0
                     )
 
-                return not_required_nullable_one_of_models_type_0
+                return not_required_nullable_one_of_models_type0
             except:  # noqa: E722
                 pass
             try:
-                not_required_nullable_one_of_models_type_1: Union[Unset, ModelWithUnionProperty]
+                not_required_nullable_one_of_models_type1: Union[Unset, ModelWithUnionProperty]
                 if not isinstance(data, dict):
                     raise TypeError()
-                not_required_nullable_one_of_models_type_1 = UNSET
-                _not_required_nullable_one_of_models_type_1 = data
-                if not isinstance(_not_required_nullable_one_of_models_type_1, Unset):
-                    not_required_nullable_one_of_models_type_1 = ModelWithUnionProperty.from_dict(
-                        _not_required_nullable_one_of_models_type_1
+                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):
+                    not_required_nullable_one_of_models_type1 = ModelWithUnionProperty.from_dict(
+                        _not_required_nullable_one_of_models_type1
                     )
 
-                return not_required_nullable_one_of_models_type_1
+                return not_required_nullable_one_of_models_type1
             except:  # noqa: E722
                 pass
             return cast(Union[FreeFormModel, ModelWithUnionProperty, None, Unset, str], data)

Diff for: end_to_end_tests/golden-record/my_test_api_client/models/model_with_union_property.py

@@ -44,26 +44,26 @@ def _parse_a_property(data: object) -> Union[AnEnum, AnIntEnum, Unset]:
             if isinstance(data, Unset):
                 return data
             try:
-                a_property_type_0: Union[Unset, AnEnum]
+                a_property_type0: Union[Unset, AnEnum]
                 if not isinstance(data, str):
                     raise TypeError()
-                a_property_type_0 = UNSET
-                _a_property_type_0 = data
-                if not isinstance(_a_property_type_0, Unset):
-                    a_property_type_0 = AnEnum(_a_property_type_0)
+                a_property_type0 = UNSET
+                _a_property_type0 = data
+                if not isinstance(_a_property_type0, Unset):
+                    a_property_type0 = AnEnum(_a_property_type0)
 
-                return a_property_type_0
+                return a_property_type0
             except:  # noqa: E722
                 pass
             if not isinstance(data, int):
                 raise TypeError()
-            a_property_type_1: Union[Unset, AnIntEnum]
-            a_property_type_1 = UNSET
-            _a_property_type_1 = data
-            if not isinstance(_a_property_type_1, Unset):
-                a_property_type_1 = AnIntEnum(_a_property_type_1)
+            a_property_type1: Union[Unset, AnIntEnum]
+            a_property_type1 = UNSET
+            _a_property_type1 = data
+            if not isinstance(_a_property_type1, Unset):
+                a_property_type1 = AnIntEnum(_a_property_type1)
 
-            return a_property_type_1
+            return a_property_type1
 
         a_property = _parse_a_property(d.pop("a_property", UNSET))
 

Diff for: end_to_end_tests/golden-record/my_test_api_client/models/model_with_union_property_inlined.py

@@ -46,26 +46,26 @@ def _parse_fruit(
             if isinstance(data, Unset):
                 return data
             try:
-                fruit_type_0: Union[Unset, ModelWithUnionPropertyInlinedFruitType0]
+                fruit_type0: Union[Unset, ModelWithUnionPropertyInlinedFruitType0]
                 if not isinstance(data, dict):
                     raise TypeError()
-                fruit_type_0 = UNSET
-                _fruit_type_0 = data
-                if not isinstance(_fruit_type_0, Unset):
-                    fruit_type_0 = ModelWithUnionPropertyInlinedFruitType0.from_dict(_fruit_type_0)
+                fruit_type0 = UNSET
+                _fruit_type0 = data
+                if not isinstance(_fruit_type0, Unset):
+                    fruit_type0 = ModelWithUnionPropertyInlinedFruitType0.from_dict(_fruit_type0)
 
-                return fruit_type_0
+                return fruit_type0
             except:  # noqa: E722
                 pass
             if not isinstance(data, dict):
                 raise TypeError()
-            fruit_type_1: Union[Unset, ModelWithUnionPropertyInlinedFruitType1]
-            fruit_type_1 = UNSET
-            _fruit_type_1 = data
-            if not isinstance(_fruit_type_1, Unset):
-                fruit_type_1 = ModelWithUnionPropertyInlinedFruitType1.from_dict(_fruit_type_1)
+            fruit_type1: Union[Unset, ModelWithUnionPropertyInlinedFruitType1]
+            fruit_type1 = UNSET
+            _fruit_type1 = data
+            if not isinstance(_fruit_type1, Unset):
+                fruit_type1 = ModelWithUnionPropertyInlinedFruitType1.from_dict(_fruit_type1)
 
-            return fruit_type_1
+            return fruit_type1
 
         fruit = _parse_fruit(d.pop("fruit", UNSET))