def test_custom_field_serializer():
@deserialize
@serialize
@dataclass
class Foo:
dt1: datetime
dt2: datetime = field(
metadata={
'serde_serializer': lambda x: x.strftime('%d/%m/%y'),
'serde_deserializer':
lambda x: datetime.strptime(x, '%d/%m/%y'),
})
dt3: Optional[datetime] = field(
metadata={
'serde_serializer':
lambda x: x.strftime('%d/%m/%y') if x else None,
'serde_deserializer':
lambda x: datetime.strptime(x, '%d/%m/%y') if x else None,
})
dt = datetime(2021, 1, 1, 0, 0, 0)
f = Foo(dt, dt, None)
assert to_json(
f) == '{"dt1": "2021-01-01T00:00:00", "dt2": "01/01/21", "dt3": null}'
assert f == from_json(Foo, to_json(f))
assert to_tuple(f) == (datetime(2021, 1, 1, 0, 0), '01/01/21', None)
assert f == from_tuple(Foo, to_tuple(f))
def test_union_optional():
v = PriOptUnion(10)
s = '{"v": 10}'
assert s == to_json(v)
assert v == from_json(PriOptUnion, s)
v = PriOptUnion(None)
s = '{"v": null}'
assert s == to_json(v)
assert v == from_json(PriOptUnion, s)
v = PriOptUnion("foo")
s = '{"v": "foo"}'
assert s == to_json(v)
assert v == from_json(PriOptUnion, s)
v = PriOptUnion(10.0)
s = '{"v": 10.0}'
assert s == to_json(v)
assert v == from_json(PriOptUnion, s)
v = PriOptUnion(False)
s = '{"v": false}'
assert s == to_json(v)
assert v == from_json(PriOptUnion, s)
def test_custom_class_serializer():
def serializer(cls, o):
if cls is datetime:
return o.strftime('%d/%m/%y')
else:
raise SerdeSkip()
def deserializer(cls, o):
if cls is datetime:
return datetime.strptime(o, '%d/%m/%y')
else:
raise SerdeSkip()
@serde(serializer=serializer, deserializer=deserializer)
class Foo:
i: int
dt1: datetime
dt2: datetime
s: Optional[str] = None
u: Union[str, int] = 10
dt = datetime(2021, 1, 1, 0, 0, 0)
f = Foo(10, dt, dt)
assert to_json(
f
) == '{"i": 10, "dt1": "01/01/21", "dt2": "01/01/21", "s": null, "u": 10}'
assert f == from_json(Foo, to_json(f))
assert to_tuple(f) == (10, '01/01/21', '01/01/21', None, 10)
assert f == from_tuple(Foo, to_tuple(f))
def test_override_by_default_serializer():
def serializer(cls, o):
if cls is datetime:
return o.strftime('%d/%m/%y')
else:
raise SerdeSkip()
def deserializer(cls, o):
if cls is datetime:
return datetime.strptime(o, '%d/%m/%y')
else:
raise SerdeSkip()
@serde(serializer=serializer, deserializer=deserializer)
class Foo:
i: int
dt1: datetime
dt2: datetime = field(serializer=default_serializer,
deserializer=default_deserializer)
dt = datetime(2021, 1, 1, 0, 0, 0)
f = Foo(10, dt, dt)
assert to_json(
f) == '{"i": 10, "dt1": "01/01/21", "dt2": "2021-01-01T00:00:00"}'
assert f == from_json(Foo, to_json(f))
assert to_tuple(f) == (10, '01/01/21', datetime(2021, 1, 1, 0, 0))
assert f == from_tuple(Foo, to_tuple(f))
def test_field_serialize_override_class_serializer():
def serializer(cls, o):
if cls is datetime:
return o.strftime('%d/%m/%y')
else:
raise SerdeSkip()
def deserializer(cls, o):
if cls is datetime:
return datetime.strptime(o, '%d/%m/%y')
else:
raise SerdeSkip()
@serde(serializer=serializer, deserializer=deserializer)
class Foo:
i: int
dt1: datetime
dt2: datetime = field(
serializer=lambda x: x.strftime('%y.%m.%d'),
deserializer=lambda x: datetime.strptime(x, '%y.%m.%d'))
dt = datetime(2021, 1, 1, 0, 0, 0)
f = Foo(10, dt, dt)
assert to_json(f) == '{"i": 10, "dt1": "01/01/21", "dt2": "21.01.01"}'
assert f == from_json(Foo, to_json(f))
assert to_tuple(f) == (10, '01/01/21', '21.01.01')
assert f == from_tuple(Foo, to_tuple(f))
def test_custom_class_serializer():
def serializer(cls, o):
if cls is datetime:
return o.strftime('%d/%m/%y')
else:
raise SerdeSkip()
def deserializer(cls, o):
if cls is datetime:
return datetime.strptime(o, '%d/%m/%y')
else:
raise SerdeSkip()
@deserialize(deserializer=deserializer)
@serialize(serializer=serializer)
@dataclass
class Foo:
i: int
dt1: datetime
dt2: datetime
dt = datetime(2021, 1, 1, 0, 0, 0)
f = Foo(10, dt, dt)
assert to_json(f) == '{"i": 10, "dt1": "01/01/21", "dt2": "01/01/21"}'
assert f == from_json(Foo, to_json(f))
assert to_tuple(f) == (10, '01/01/21', '01/01/21')
assert f == from_tuple(Foo, to_tuple(f))
def test_json():
p = Pri(10, 'foo', 100.0, True)
s = '{"i": 10, "s": "foo", "f": 100.0, "b": true}'
assert s == to_json(p)
assert '10' == to_json(10)
assert '[10, 20, 30]' == to_json([10, 20, 30])
assert '{"foo": 10, "fuga": 10}' == to_json({'foo': 10, 'fuga': 10})
def test_wrong_signature():
@serde
class Foo:
i: int = field(serializer=lambda: '10', deserializer=lambda: 10)
f = Foo(10)
with pytest.raises(TypeError):
to_json(f)
with pytest.raises(TypeError):
from_json(Foo, '{"i": 10}')
def main():
resources = [
Resource("Stack Overflow", "b6469c3f31653d281bbbfa6f94d60fea130abe38"),
Resource("GitHub", "5cb7a0c47e53854cd00e1a968de5abce1c124601", metadata={"headquarters": "San Francisco"}),
]
print(to_json(resources))
world = World('satoshi', ['Rattata', 'Pidgey'], 'Pikachu')
print(to_json(world))
world = World('green', [], 'Charmander')
print(to_json(world))
def test_union_containers():
v = ContUnion([1, 2, 3])
s = '{"v": [1, 2, 3]}'
assert s == to_json(v)
assert v == from_json(ContUnion, s)
v = ContUnion(['1', '2', '3'])
s = '{"v": ["1", "2", "3"]}'
assert s == to_json(v)
assert v == from_json(ContUnion, s)
v = ContUnion({'a': 1, 'b': 2, 'c': 3})
s = '{"v": {"a": 1, "b": 2, "c": 3}}'
assert s == to_json(v)
assert v == from_json(ContUnion, s)
def test_raise_error():
def raise_exception(_):
raise Exception()
@serde
class Foo:
i: int = field(serializer=raise_exception,
deserializer=raise_exception)
f = Foo(10)
with pytest.raises(Exception):
to_json(f)
with pytest.raises(Exception):
from_json(Foo, '{"i": 10}')
def test_wrong_signature():
@deserialize
@serialize
@dataclass
class Foo:
i: int = field(metadata={
'serde_serializer': lambda: '10',
'serde_deserializer': lambda: 10
})
f = Foo(10)
with pytest.raises(TypeError):
to_json(f)
with pytest.raises(TypeError):
from_json(Foo, '{"i": 10}')
def test_union_containers():
v = ContUnion([1, 2, 3])
s = '{"v": [1, 2, 3]}'
assert s == to_json(v)
assert v == from_json(ContUnion, s)
v = ContUnion(['1', '2', '3'])
s = '{"v": ["1", "2", "3"]}'
assert s == to_json(v)
assert v == from_json(ContUnion, s)
v = ContUnion({'a': 1, 'b': 2, 'c': 3})
s = '{"v": {"a": 1, "b": 2, "c": 3}}'
assert s == to_json(v)
# Note: this only works because Dict[str, int] comes first in Union otherwise a List would win
assert v == from_json(ContUnion, s)
def update(self, update: UpdateRequest):
response = self.session.post(
self.prepare_url("update"),
data=to_json(update),
headers={"Content-Type": "application/json"},
)
return from_json(RetrievalResponse, response.content)
def todos():
print(request.method)
if request.method == 'GET':
body = to_json([ToDo(1, 'Play games', 'Play 聖剣伝説3', False)])
return Response(body, mimetype='application/json')
else:
todo = from_json(ToDo, request.get_data())
return f'A new ToDo {todo} successfully created.'
def query(self, query: QueryRequest):
response = self.session.post(
self.prepare_url("query"),
data=to_json(query),
headers={"Content-Type": "application/json"},
)
return from_json(QueryResponse, response.content)
def start_upload(self, request: "UploadStartRequest") -> "UploadResponse":
response = self.session.post(
self.prepare_url_unsafe(request.upload_path),
data=to_json(request),
headers={"Content-Type": "application/json"},
)
response_obj = from_json(UploadResponse, response.content)
return response_obj
def test_raise_error():
def raise_exception(_):
raise Exception()
@deserialize
@serialize
@dataclass
class Foo:
i: int = field(
metadata={
'serde_serializer': raise_exception,
'serde_deserializer': raise_exception
})
f = Foo(10)
with pytest.raises(Exception):
to_json(f)
with pytest.raises(Exception):
from_json(Foo, '{"i": 10}')
def test_union():
v = PriUnion(10)
s = '{"v": 10}'
assert s == to_json(v)
assert v == from_json(PriUnion, s)
v = PriUnion(10.0)
s = '{"v": 10.0}'
assert s == to_json(v)
assert v == from_json(PriUnion, s)
v = PriUnion('foo')
s = '{"v": "foo"}'
assert s == to_json(v)
assert v == from_json(PriUnion, s)
v = PriUnion(True)
s = '{"v": true}'
assert s == to_json(v)
assert v == from_json(PriUnion, s)
def test_union():
v = PriUnion(10)
s = '{"v": 10}'
assert s == to_json(v)
print(f'foo {v.__serde_hidden__.code}')
assert v == from_json(PriUnion, s)
v = PriUnion(10.0)
s = '{"v": 10.0}'
assert s == to_json(v)
assert v == from_json(PriUnion, s)
v = PriUnion('foo')
s = '{"v": "foo"}'
assert s == to_json(v)
assert v == from_json(PriUnion, s)
v = PriUnion(True)
s = '{"v": true}'
assert s == to_json(v)
assert v == from_json(PriUnion, s)
def test_union_with_complex_types():
@serde
class A:
v: Union[int, IPv4Address, UUID]
a_int = A(1)
a_int_json = '{"v": 1}'
assert to_json(a_int) == a_int_json
assert from_json(A, a_int_json) == a_int
assert a_int == from_dict(A, to_dict(a_int))
a_ip = A(IPv4Address("127.0.0.1"))
a_ip_json = '{"v": "127.0.0.1"}'
assert to_json(a_ip) == a_ip_json
assert from_json(A, a_ip_json) == a_ip
assert a_ip == from_dict(A, to_dict(a_ip))
a_uid = A(UUID("a317958e-4cbb-4213-9f23-eaff1563c472"))
a_uid_json = '{"v": "a317958e-4cbb-4213-9f23-eaff1563c472"}'
assert to_json(a_uid) == a_uid_json
assert from_json(A, a_uid_json) == a_uid
assert a_uid == from_dict(A, to_dict(a_uid))
def test_flatten_simple():
@serde
class Bar:
c: float
d: bool
@serde
class Foo:
a: int
b: str
bar: Bar = field(flatten=True)
f = Foo(a=10, b='foo', bar=Bar(c=100.0, d=True))
s = '{"a": 10, "b": "foo", "c": 100.0, "d": true}'
assert to_json(f) == s
assert from_json(Foo, s) == f
def test_convert_sets_option():
@serialize
class A:
v: Set[str]
a = A({"a", "b"})
a_json = to_json(a)
# sets are unordered so the list order is not stable
assert a_json == '{"v": ["a", "b"]}' or a_json == '{"v": ["b", "a"]}'
a_msgpack = to_msgpack(a)
# sets are unordered so the list order is not stable
assert a_msgpack == b'\x81\xa1v\x92\xa1a\xa1b' or a_msgpack == b'\x81\xa1v\x92\xa1b\xa1a'
a_dict = to_dict(a, convert_sets=True)
# sets are unordered so the list order is not stable
assert a_dict == {"v": ["a", "b"]} or a_dict == {"v": ["b", "a"]}
assert {"v": {"a", "b"}} == to_dict(a, convert_sets=False)
def test_flatten_simple():
@deserialize
@serialize
@dataclass
class Bar:
c: float
d: bool
@deserialize
@serialize
@dataclass
class Foo:
a: int
b: str
bar: Bar = field(metadata={'serde_flatten': True})
f = Foo(a=10, b='foo', bar=Bar(c=100.0, d=True))
s = '{"a": 10, "b": "foo", "c": 100.0, "d": true}'
assert to_json(f) == s
assert from_json(Foo, s) == f
def main():
print(to_json(Foo(class_name='Foo')))
def dump_state(dir: str, state: State):
s = to_json(state)
with open(_state_path(dir), "w") as state_file:
state_file.write(s)
class IE(enum.IntEnum):
V0 = enum.auto()
V1 = enum.auto()
V2 = enum.auto()
@deserialize
@serialize
@dataclass
class Foo:
v0: IE
v1: IE = IE.V1 # Default enum value.
v2: E = E.S
v3: imported.ImportedEnum = imported.ImportedEnum.V3 # Use enum imported from other module.
v4: E = E.N # Use nested enum.
if __name__ == "__main__":
f = Foo(IE.V0)
s = to_json(f)
print(s)
f = from_json(Foo, s)
print(f)
s = to_json(f)
# You can also pass an enum-compabitle value (in this case True for E.B).
# Caveat: Foo takes any value IE accepts. e.g., Foo(True) is also valid.
s = to_json(Foo(3))
print(s)