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_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 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 upload_blob(self, request: "UploadBlobRequest"):
response = self.session.post(
self.prepare_url_unsafe(request.upload_path),
files=encode_as_multipart(request),
)
response_obj = from_json(UploadResponse, response.content)
return response_obj
def tail(
self,
project_name: str,
bucket_name: str,
type: typing.Union[typing.Literal['folders'], typing.Literal['files']],
batch_start: Optional[datetime] = None,
batch_end: Optional[datetime] = None,
folder_id: Optional[typing.Union[int, typing.List[int]]] = None,
include_parents: Optional[bool] = False,
) -> typing.Tuple[List[File], List[Folder]]:
container = TailResultContainer(bucket_name, project_name)
if batch_start and batch_end:
args = dict(
batch_start=batch_start.isoformat(timespec="seconds"),
batch_end=batch_end.isoformat(timespec="seconds"),
type=type,
)
else:
args = dict(
folder_id=folder_id,
type=type,
)
response = self.session.post(self.prepare_url(project_name, 'tail', bucket_name), json=args, stream=True)
for line in response.iter_lines():
if line:
container.add(from_json(TailNode, line))
return container.resolve_files(), container.resolve_folders(include_parents=include_parents)
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_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 _load_state(dir: str) -> Optional[State]:
state_path = _state_path(dir)
if os.path.exists(state_path):
with open(state_path) as state_file:
return from_json(State, state_file.read())
else:
return None
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_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 touch_folder(
self, project_name: str, bucket_name: str, folder_path: str
) -> FoldersResponse:
response = self.session.get(
self.prepare_url(project_name, "folder", "touch", bucket_name, folder_path)
)
return from_json(FoldersResponse, response.content)
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_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_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 create_folder(
self, project_name: str, bucket_name: str, folder_path: str
) -> FoldersAndFilesResponse:
response = self.session.post(
self.prepare_url(project_name, "folder", "create", bucket_name, folder_path)
)
response_obj = from_json(FoldersAndFilesResponse, response.content)
return response_obj
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 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 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_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 authorize_upload(
self, project_name: str, bucket_name: str, file_path: str
) -> "UploadResponse":
response = self.session.post(
self.prepare_url("authorize", "upload"),
json=dict(
project_name=project_name, bucket_name=bucket_name, file_path=file_path
),
)
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)
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 list_folder(
self, project_name: str, bucket_name: str, folder_path: Optional[str] = None
) -> FoldersAndFilesResponse:
if folder_path:
response = self.session.get(
self.prepare_url(project_name, "list", bucket_name, folder_path)
)
else:
response = self.session.get(
self.prepare_url(project_name, "list", bucket_name)
)
return from_json(FoldersAndFilesResponse, response.content)
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 consume_pages():
while True:
try:
r = self.session.post(self.prepare_url("retrieve"),
json=args)
except HTTPError as e:
if b"not found" in e.response.content:
if e.response.status_code == 422:
break
raise e
paged = from_json(RetrievalResponse, r.content)
response.extend(paged)
if "page" not in args:
break
if paged.empty():
break
args["page"] += 1
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 find(
self,
project_name: str,
bucket_name: str,
params: List[typing.Mapping],
limit: Optional[int] = None,
offset: Optional[int] = None,
hide_paths=False,
) -> FoldersAndFilesResponse:
limit_set = True
if not limit:
limit_set = False
limit = 1000
if not offset:
offset = 0
args = dict(
params=params,
hide_paths=hide_paths,
limit=limit,
offset=offset,
)
result = FoldersAndFilesResponse(folders=[], files=[])
while True:
response = self.session.post(
self.prepare_url(project_name, "find", bucket_name), json=args
)
response_obj = from_json(FoldersAndFilesResponse, response.content)
result.extend(response_obj)
if response_obj.empty() or limit_set:
break
args["offset"] += max(len(response_obj.files), len(response_obj.folders))
return result
