Projekt

Obecné

Profil

Stáhnout (3.3 KB) Statistiky
| Větev: | Tag: | Revize:
1
import datetime
2

    
3
import six
4
import typing
5

    
6

    
7
def _deserialize(data, klass):
8
    """Deserializes dict, list, str into an object.
9

    
10
    :param data: dict, list or str.
11
    :param klass: class literal, or string of class name.
12

    
13
    :return: object.
14
    """
15
    if data is None:
16
        return None
17

    
18
    if klass in six.integer_types or klass in (float, str, bool):
19
        return _deserialize_primitive(data, klass)
20
    elif klass == object:
21
        return _deserialize_object(data)
22
    elif klass == datetime.date:
23
        return deserialize_date(data)
24
    elif klass == datetime.datetime:
25
        return deserialize_datetime(data)
26
    elif hasattr(klass, '__origin__'):
27
        if klass.__origin__ == list:
28
            return _deserialize_list(data, klass.__args__[0])
29
        if klass.__origin__ == dict:
30
            return _deserialize_dict(data, klass.__args__[1])
31
    else:
32
        return deserialize_model(data, klass)
33

    
34

    
35
def _deserialize_primitive(data, klass):
36
    """Deserializes to primitive type.
37

    
38
    :param data: data to deserialize.
39
    :param klass: class literal.
40

    
41
    :return: int, long, float, str, bool.
42
    :rtype: int | long | float | str | bool
43
    """
44
    try:
45
        value = klass(data)
46
    except UnicodeEncodeError:
47
        value = six.u(data)
48
    except TypeError:
49
        value = data
50
    return value
51

    
52

    
53
def _deserialize_object(value):
54
    """Return a original value.
55

    
56
    :return: object.
57
    """
58
    return value
59

    
60

    
61
def deserialize_date(string):
62
    """Deserializes string to date.
63

    
64
    :param string: str.
65
    :type string: str
66
    :return: date.
67
    :rtype: date
68
    """
69
    try:
70
        from dateutil.parser import parse
71
        return parse(string).date()
72
    except ImportError:
73
        return string
74

    
75

    
76
def deserialize_datetime(string):
77
    """Deserializes string to datetime.
78

    
79
    The string should be in iso8601 datetime format.
80

    
81
    :param string: str.
82
    :type string: str
83
    :return: datetime.
84
    :rtype: datetime
85
    """
86
    try:
87
        from dateutil.parser import parse
88
        return parse(string)
89
    except ImportError:
90
        return string
91

    
92

    
93
def deserialize_model(data, klass):
94
    """Deserializes list or dict to model.
95

    
96
    :param data: dict, list.
97
    :type data: dict | list
98
    :param klass: class literal.
99
    :return: model object.
100
    """
101
    instance = klass()
102

    
103
    if not instance.swagger_types:
104
        return data
105

    
106
    for attr, attr_type in six.iteritems(instance.swagger_types):
107
        if data is not None \
108
                and instance.attribute_map[attr] in data \
109
                and isinstance(data, (list, dict)):
110
            value = data[instance.attribute_map[attr]]
111
            setattr(instance, attr, _deserialize(value, attr_type))
112

    
113
    return instance
114

    
115

    
116
def _deserialize_list(data, boxed_type):
117
    """Deserializes a list and its elements.
118

    
119
    :param data: list to deserialize.
120
    :type data: list
121
    :param boxed_type: class literal.
122

    
123
    :return: deserialized list.
124
    :rtype: list
125
    """
126
    return [_deserialize(sub_data, boxed_type)
127
            for sub_data in data]
128

    
129

    
130
def _deserialize_dict(data, boxed_type):
131
    """Deserializes a dict and its elements.
132

    
133
    :param data: dict to deserialize.
134
    :type data: dict
135
    :param boxed_type: class literal.
136

    
137
    :return: deserialized dict.
138
    :rtype: dict
139
    """
140
    return {k: _deserialize(v, boxed_type)
141
            for k, v in six.iteritems(data)}
(4-4/4)