forked from loafle/openapi-generator-original
00de163655
* adopt python3.5+ syntax removing some residual python2 code, since it is not supported anymore, like: - no need for `six` anymore - no need for encoding utf8 in top file - remove `object` inheritance in base model - remove absolute import `__future__` * generate samples applying the new templates * update python ignore pattern ignore all the `.venv` folders
148 lines
3.4 KiB
Python
148 lines
3.4 KiB
Python
import datetime
|
|
|
|
import typing
|
|
from openapi_server import typing_utils
|
|
|
|
|
|
def _deserialize(data, klass):
|
|
"""Deserializes dict, list, str into an object.
|
|
|
|
:param data: dict, list or str.
|
|
:param klass: class literal, or string of class name.
|
|
|
|
:return: object.
|
|
"""
|
|
if data is None:
|
|
return None
|
|
|
|
if klass in (int, float, str, bool, bytearray):
|
|
return _deserialize_primitive(data, klass)
|
|
elif klass == object:
|
|
return _deserialize_object(data)
|
|
elif klass == datetime.date:
|
|
return deserialize_date(data)
|
|
elif klass == datetime.datetime:
|
|
return deserialize_datetime(data)
|
|
elif typing_utils.is_generic(klass):
|
|
if typing_utils.is_list(klass):
|
|
return _deserialize_list(data, klass.__args__[0])
|
|
if typing_utils.is_dict(klass):
|
|
return _deserialize_dict(data, klass.__args__[1])
|
|
else:
|
|
return deserialize_model(data, klass)
|
|
|
|
|
|
def _deserialize_primitive(data, klass):
|
|
"""Deserializes to primitive type.
|
|
|
|
:param data: data to deserialize.
|
|
:param klass: class literal.
|
|
|
|
:return: int, long, float, str, bool.
|
|
:rtype: int | long | float | str | bool
|
|
"""
|
|
try:
|
|
value = klass(data)
|
|
except UnicodeEncodeError:
|
|
value = data
|
|
except TypeError:
|
|
value = data
|
|
return value
|
|
|
|
|
|
def _deserialize_object(value):
|
|
"""Return an original value.
|
|
|
|
:return: object.
|
|
"""
|
|
return value
|
|
|
|
|
|
def deserialize_date(string):
|
|
"""Deserializes string to date.
|
|
|
|
:param string: str.
|
|
:type string: str
|
|
:return: date.
|
|
:rtype: date
|
|
"""
|
|
if string is None:
|
|
return None
|
|
|
|
try:
|
|
from dateutil.parser import parse
|
|
return parse(string).date()
|
|
except ImportError:
|
|
return string
|
|
|
|
|
|
def deserialize_datetime(string):
|
|
"""Deserializes string to datetime.
|
|
|
|
The string should be in iso8601 datetime format.
|
|
|
|
:param string: str.
|
|
:type string: str
|
|
:return: datetime.
|
|
:rtype: datetime
|
|
"""
|
|
if string is None:
|
|
return None
|
|
|
|
try:
|
|
from dateutil.parser import parse
|
|
return parse(string)
|
|
except ImportError:
|
|
return string
|
|
|
|
|
|
def deserialize_model(data, klass):
|
|
"""Deserializes list or dict to model.
|
|
|
|
:param data: dict, list.
|
|
:type data: dict | list
|
|
:param klass: class literal.
|
|
:return: model object.
|
|
"""
|
|
instance = klass()
|
|
|
|
if not instance.openapi_types:
|
|
return data
|
|
|
|
for attr, attr_type in instance.openapi_types.items():
|
|
if data is not None \
|
|
and instance.attribute_map[attr] in data \
|
|
and isinstance(data, (list, dict)):
|
|
value = data[instance.attribute_map[attr]]
|
|
setattr(instance, attr, _deserialize(value, attr_type))
|
|
|
|
return instance
|
|
|
|
|
|
def _deserialize_list(data, boxed_type):
|
|
"""Deserializes a list and its elements.
|
|
|
|
:param data: list to deserialize.
|
|
:type data: list
|
|
:param boxed_type: class literal.
|
|
|
|
:return: deserialized list.
|
|
:rtype: list
|
|
"""
|
|
return [_deserialize(sub_data, boxed_type)
|
|
for sub_data in data]
|
|
|
|
|
|
def _deserialize_dict(data, boxed_type):
|
|
"""Deserializes a dict and its elements.
|
|
|
|
:param data: dict to deserialize.
|
|
:type data: dict
|
|
:param boxed_type: class literal.
|
|
|
|
:return: deserialized dict.
|
|
:rtype: dict
|
|
"""
|
|
return {k: _deserialize(v, boxed_type)
|
|
for k, v in data.items() }
|