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