-
Notifications
You must be signed in to change notification settings - Fork 2
Expand file tree
/
Copy pathserialization.py
More file actions
276 lines (228 loc) · 9.59 KB
/
serialization.py
File metadata and controls
276 lines (228 loc) · 9.59 KB
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
# This file was auto-generated by Fern from our API Definition.
import collections
import inspect
import typing
import pydantic
import typing_extensions
class FieldMetadata:
"""
Metadata class used to annotate fields to provide additional information.
Example:
class MyDict(TypedDict):
field: typing.Annotated[str, FieldMetadata(alias="field_name")]
Will serialize: `{"field": "value"}`
To: `{"field_name": "value"}`
"""
alias: str
def __init__(self, *, alias: str) -> None:
self.alias = alias
def convert_and_respect_annotation_metadata(
*,
object_: typing.Any,
annotation: typing.Any,
inner_type: typing.Optional[typing.Any] = None,
direction: typing.Literal["read", "write"],
) -> typing.Any:
"""
Respect the metadata annotations on a field, such as aliasing. This function effectively
manipulates the dict-form of an object to respect the metadata annotations. This is primarily used for
TypedDicts, which cannot support aliasing out of the box, and can be extended for additional
utilities, such as defaults.
Parameters
----------
object_ : typing.Any
annotation : type
The type we're looking to apply typing annotations from
inner_type : typing.Optional[type]
Returns
-------
typing.Any
"""
if object_ is None:
return None
if inner_type is None:
inner_type = annotation
clean_type = _remove_annotations(inner_type)
# Pydantic models
if (
inspect.isclass(clean_type)
and issubclass(clean_type, pydantic.BaseModel)
and isinstance(object_, typing.Mapping)
):
return _convert_mapping(object_, clean_type, direction)
# TypedDicts
if typing_extensions.is_typeddict(clean_type) and isinstance(object_, typing.Mapping):
return _convert_mapping(object_, clean_type, direction)
if (
typing_extensions.get_origin(clean_type) == typing.Dict
or typing_extensions.get_origin(clean_type) == dict
or clean_type == typing.Dict
) and isinstance(object_, typing.Dict):
key_type = typing_extensions.get_args(clean_type)[0]
value_type = typing_extensions.get_args(clean_type)[1]
return {
key: convert_and_respect_annotation_metadata(
object_=value,
annotation=annotation,
inner_type=value_type,
direction=direction,
)
for key, value in object_.items()
}
# If you're iterating on a string, do not bother to coerce it to a sequence.
if not isinstance(object_, str):
if (
typing_extensions.get_origin(clean_type) == typing.Set
or typing_extensions.get_origin(clean_type) == set
or clean_type == typing.Set
) and isinstance(object_, typing.Set):
inner_type = typing_extensions.get_args(clean_type)[0]
return {
convert_and_respect_annotation_metadata(
object_=item,
annotation=annotation,
inner_type=inner_type,
direction=direction,
)
for item in object_
}
elif (
(
typing_extensions.get_origin(clean_type) == typing.List
or typing_extensions.get_origin(clean_type) == list
or clean_type == typing.List
)
and isinstance(object_, typing.List)
) or (
(
typing_extensions.get_origin(clean_type) == typing.Sequence
or typing_extensions.get_origin(clean_type) == collections.abc.Sequence
or clean_type == typing.Sequence
)
and isinstance(object_, typing.Sequence)
):
inner_type = typing_extensions.get_args(clean_type)[0]
return [
convert_and_respect_annotation_metadata(
object_=item,
annotation=annotation,
inner_type=inner_type,
direction=direction,
)
for item in object_
]
if typing_extensions.get_origin(clean_type) == typing.Union:
# We should be able to ~relatively~ safely try to convert keys against all
# member types in the union, the edge case here is if one member aliases a field
# of the same name to a different name from another member
# Or if another member aliases a field of the same name that another member does not.
for member in typing_extensions.get_args(clean_type):
object_ = convert_and_respect_annotation_metadata(
object_=object_,
annotation=annotation,
inner_type=member,
direction=direction,
)
return object_
annotated_type = _get_annotation(annotation)
if annotated_type is None:
return object_
# If the object is not a TypedDict, a Union, or other container (list, set, sequence, etc.)
# Then we can safely call it on the recursive conversion.
return object_
def _convert_mapping(
object_: typing.Mapping[str, object],
expected_type: typing.Any,
direction: typing.Literal["read", "write"],
) -> typing.Mapping[str, object]:
converted_object: typing.Dict[str, object] = {}
try:
annotations = typing_extensions.get_type_hints(expected_type, include_extras=True)
except NameError:
# The TypedDict contains a circular reference, so
# we use the __annotations__ attribute directly.
annotations = getattr(expected_type, "__annotations__", {})
aliases_to_field_names = _get_alias_to_field_name(annotations)
for key, value in object_.items():
if direction == "read" and key in aliases_to_field_names:
dealiased_key = aliases_to_field_names.get(key)
if dealiased_key is not None:
type_ = annotations.get(dealiased_key)
else:
type_ = annotations.get(key)
# Note you can't get the annotation by the field name if you're in read mode, so you must check the aliases map
#
# So this is effectively saying if we're in write mode, and we don't have a type, or if we're in read mode and we don't have an alias
# then we can just pass the value through as is
if type_ is None:
converted_object[key] = value
elif direction == "read" and key not in aliases_to_field_names:
converted_object[key] = convert_and_respect_annotation_metadata(
object_=value, annotation=type_, direction=direction
)
else:
converted_object[_alias_key(key, type_, direction, aliases_to_field_names)] = (
convert_and_respect_annotation_metadata(object_=value, annotation=type_, direction=direction)
)
return converted_object
def _get_annotation(type_: typing.Any) -> typing.Optional[typing.Any]:
maybe_annotated_type = typing_extensions.get_origin(type_)
if maybe_annotated_type is None:
return None
if maybe_annotated_type == typing_extensions.NotRequired:
type_ = typing_extensions.get_args(type_)[0]
maybe_annotated_type = typing_extensions.get_origin(type_)
if maybe_annotated_type == typing_extensions.Annotated:
return type_
return None
def _remove_annotations(type_: typing.Any) -> typing.Any:
maybe_annotated_type = typing_extensions.get_origin(type_)
if maybe_annotated_type is None:
return type_
if maybe_annotated_type == typing_extensions.NotRequired:
return _remove_annotations(typing_extensions.get_args(type_)[0])
if maybe_annotated_type == typing_extensions.Annotated:
return _remove_annotations(typing_extensions.get_args(type_)[0])
return type_
def get_alias_to_field_mapping(type_: typing.Any) -> typing.Dict[str, str]:
annotations = typing_extensions.get_type_hints(type_, include_extras=True)
return _get_alias_to_field_name(annotations)
def get_field_to_alias_mapping(type_: typing.Any) -> typing.Dict[str, str]:
annotations = typing_extensions.get_type_hints(type_, include_extras=True)
return _get_field_to_alias_name(annotations)
def _get_alias_to_field_name(
field_to_hint: typing.Dict[str, typing.Any],
) -> typing.Dict[str, str]:
aliases = {}
for field, hint in field_to_hint.items():
maybe_alias = _get_alias_from_type(hint)
if maybe_alias is not None:
aliases[maybe_alias] = field
return aliases
def _get_field_to_alias_name(
field_to_hint: typing.Dict[str, typing.Any],
) -> typing.Dict[str, str]:
aliases = {}
for field, hint in field_to_hint.items():
maybe_alias = _get_alias_from_type(hint)
if maybe_alias is not None:
aliases[field] = maybe_alias
return aliases
def _get_alias_from_type(type_: typing.Any) -> typing.Optional[str]:
maybe_annotated_type = _get_annotation(type_)
if maybe_annotated_type is not None:
# The actual annotations are 1 onward, the first is the annotated type
annotations = typing_extensions.get_args(maybe_annotated_type)[1:]
for annotation in annotations:
if isinstance(annotation, FieldMetadata) and annotation.alias is not None:
return annotation.alias
return None
def _alias_key(
key: str,
type_: typing.Any,
direction: typing.Literal["read", "write"],
aliases_to_field_names: typing.Dict[str, str],
) -> str:
if direction == "read":
return aliases_to_field_names.get(key, key)
return _get_alias_from_type(type_=type_) or key