4
4
import attr
5
5
from dateutil .parser import isoparse
6
6
7
+ from ..models .a_model_model import AModelModel
8
+ from ..models .a_model_not_required_model import AModelNotRequiredModel
9
+ from ..models .a_model_not_required_nullable_model import AModelNotRequiredNullableModel
10
+ from ..models .a_model_nullable_model import AModelNullableModel
7
11
from ..models .an_enum import AnEnum
8
12
from ..models .different_enum import DifferentEnum
9
- from ..models .model_with_union_property import ModelWithUnionProperty
10
13
from ..types import UNSET , Unset
11
14
12
15
T = TypeVar ("T" , bound = "AModel" )
@@ -20,16 +23,16 @@ class AModel:
20
23
a_camel_date_time : Union [datetime .datetime , datetime .date ]
21
24
a_date : datetime .date
22
25
required_not_nullable : str
23
- model : Union [ ModelWithUnionProperty ]
26
+ model : AModelModel
24
27
a_nullable_date : Optional [datetime .date ]
25
28
required_nullable : Optional [str ]
26
- nullable_model : Union [ None , ModelWithUnionProperty ]
29
+ nullable_model : Optional [ AModelNullableModel ]
27
30
nested_list_of_enums : Union [Unset , List [List [DifferentEnum ]]] = UNSET
28
31
attr_1_leading_digit : Union [Unset , str ] = UNSET
29
32
not_required_nullable : Union [Unset , None , str ] = UNSET
30
33
not_required_not_nullable : Union [Unset , str ] = UNSET
31
- not_required_model : Union [Unset , ModelWithUnionProperty ] = UNSET
32
- not_required_nullable_model : Union [Unset , None , ModelWithUnionProperty ] = UNSET
34
+ not_required_model : Union [Unset , AModelNotRequiredModel ] = UNSET
35
+ not_required_nullable_model : Union [Unset , None , AModelNotRequiredNullableModel ] = UNSET
33
36
34
37
def to_dict (self ) -> Dict [str , Any ]:
35
38
an_enum_value = self .an_enum_value .value
@@ -42,8 +45,7 @@ def to_dict(self) -> Dict[str, Any]:
42
45
43
46
a_date = self .a_date .isoformat ()
44
47
required_not_nullable = self .required_not_nullable
45
- if isinstance (self .model , ModelWithUnionProperty ):
46
- model = self .model .to_dict ()
48
+ model = self .model .to_dict ()
47
49
48
50
nested_list_of_enums : Union [Unset , List [Any ]] = UNSET
49
51
if not isinstance (self .nested_list_of_enums , Unset ):
@@ -62,31 +64,17 @@ def to_dict(self) -> Dict[str, Any]:
62
64
required_nullable = self .required_nullable
63
65
not_required_nullable = self .not_required_nullable
64
66
not_required_not_nullable = self .not_required_not_nullable
65
- nullable_model : Union [None , Dict [str , Any ]]
66
- if isinstance (self .nullable_model , Unset ):
67
- nullable_model = UNSET
68
- if self .nullable_model is None :
69
- nullable_model = None
70
- else :
71
- nullable_model = self .nullable_model .to_dict ()
67
+ nullable_model = self .nullable_model .to_dict () if self .nullable_model else None
72
68
73
- not_required_model : Union [Unset , Dict [str , Any ]]
74
- if isinstance (self .not_required_model , Unset ):
75
- not_required_model = UNSET
76
- else :
77
- not_required_model = UNSET
78
- if not isinstance (self .not_required_model , Unset ):
79
- not_required_model = self .not_required_model .to_dict ()
80
-
81
- not_required_nullable_model : Union [Unset , None , Dict [str , Any ]]
82
- if isinstance (self .not_required_nullable_model , Unset ):
83
- not_required_nullable_model = UNSET
84
- elif self .not_required_nullable_model is None :
85
- not_required_nullable_model = None
86
- else :
87
- not_required_nullable_model = UNSET
88
- if not isinstance (self .not_required_nullable_model , Unset ):
89
- not_required_nullable_model = self .not_required_nullable_model .to_dict ()
69
+ not_required_model : Union [Unset , Dict [str , Any ]] = UNSET
70
+ if not isinstance (self .not_required_model , Unset ):
71
+ not_required_model = self .not_required_model .to_dict ()
72
+
73
+ not_required_nullable_model : Union [Unset , None , Dict [str , Any ]] = UNSET
74
+ if not isinstance (self .not_required_nullable_model , Unset ):
75
+ not_required_nullable_model = (
76
+ self .not_required_nullable_model .to_dict () if self .not_required_nullable_model else None
77
+ )
90
78
91
79
field_dict : Dict [str , Any ] = {}
92
80
field_dict .update (
@@ -140,14 +128,7 @@ def _parse_a_camel_date_time(data: Any) -> Union[datetime.datetime, datetime.dat
140
128
141
129
required_not_nullable = d .pop ("required_not_nullable" )
142
130
143
- def _parse_model (data : Any ) -> Union [ModelWithUnionProperty ]:
144
- data = None if isinstance (data , Unset ) else data
145
- model : Union [ModelWithUnionProperty ]
146
- model = ModelWithUnionProperty .from_dict (data )
147
-
148
- return model
149
-
150
- model = _parse_model (d .pop ("model" ))
131
+ model = AModelModel .from_dict (d .pop ("model" ))
151
132
152
133
nested_list_of_enums = []
153
134
_nested_list_of_enums = d .pop ("nested_list_of_enums" , UNSET )
@@ -174,40 +155,22 @@ def _parse_model(data: Any) -> Union[ModelWithUnionProperty]:
174
155
175
156
not_required_not_nullable = d .pop ("not_required_not_nullable" , UNSET )
176
157
177
- def _parse_nullable_model (data : Any ) -> Union [None , ModelWithUnionProperty ]:
178
- data = None if isinstance (data , Unset ) else data
179
- nullable_model : Union [None , ModelWithUnionProperty ]
180
- nullable_model = ModelWithUnionProperty .from_dict (data )
181
-
182
- return nullable_model
183
-
184
- nullable_model = _parse_nullable_model (d .pop ("nullable_model" ))
185
-
186
- def _parse_not_required_model (data : Any ) -> Union [Unset , ModelWithUnionProperty ]:
187
- data = None if isinstance (data , Unset ) else data
188
- not_required_model : Union [Unset , ModelWithUnionProperty ]
189
- not_required_model = UNSET
190
- _not_required_model = data
191
- if not isinstance (_not_required_model , Unset ):
192
- not_required_model = ModelWithUnionProperty .from_dict (cast (Dict [str , Any ], _not_required_model ))
193
-
194
- return not_required_model
195
-
196
- not_required_model = _parse_not_required_model (d .pop ("not_required_model" , UNSET ))
197
-
198
- def _parse_not_required_nullable_model (data : Any ) -> Union [Unset , None , ModelWithUnionProperty ]:
199
- data = None if isinstance (data , Unset ) else data
200
- not_required_nullable_model : Union [Unset , None , ModelWithUnionProperty ]
201
- not_required_nullable_model = UNSET
202
- _not_required_nullable_model = data
203
- if not isinstance (_not_required_nullable_model , Unset ):
204
- not_required_nullable_model = ModelWithUnionProperty .from_dict (
205
- cast (Dict [str , Any ], _not_required_nullable_model )
206
- )
207
-
208
- return not_required_nullable_model
209
-
210
- not_required_nullable_model = _parse_not_required_nullable_model (d .pop ("not_required_nullable_model" , UNSET ))
158
+ nullable_model = None
159
+ _nullable_model = d .pop ("nullable_model" )
160
+ if _nullable_model is not None :
161
+ nullable_model = AModelNullableModel .from_dict (cast (Dict [str , Any ], _nullable_model ))
162
+
163
+ not_required_model : Union [Unset , AModelNotRequiredModel ] = UNSET
164
+ _not_required_model = d .pop ("not_required_model" , UNSET )
165
+ if not isinstance (_not_required_model , Unset ):
166
+ not_required_model = AModelNotRequiredModel .from_dict (cast (Dict [str , Any ], _not_required_model ))
167
+
168
+ not_required_nullable_model = None
169
+ _not_required_nullable_model = d .pop ("not_required_nullable_model" , UNSET )
170
+ if _not_required_nullable_model is not None and not isinstance (_not_required_nullable_model , Unset ):
171
+ not_required_nullable_model = AModelNotRequiredNullableModel .from_dict (
172
+ cast (Dict [str , Any ], _not_required_nullable_model )
173
+ )
211
174
212
175
a_model = cls (
213
176
an_enum_value = an_enum_value ,
0 commit comments