def test_transform_json_types(self):
d = {
"int": 1,
"str": "qwerty",
"list": [1, 2, 3],
"dict1": {
"a": 1,
"b": 2
},
"datetime": tools.datetime.now(),
"byte": b"qwerty",
"id": tools.ObjectId(),
"dict2": None
}
d["dict2"] = d.copy()
try:
tools.json.dumps(d)
self.fail()
except TypeError:
pass
d2 = tools.transform_json_types(d)
s = tools.json.dumps(d2, indent=2)
print(s)
self.assertDictEqual(d, tools.transform_json_types(d2, direction=1))
def dejsonify(data: str,
need_transform=False) -> Union[dict, list, str, int, float]:
"""
Wrapper to json_lib.loads and tools.transform_json_types functions
:param data:
:param need_transform:
:return:
"""
data = json_lib.loads(data)
if need_transform:
transform_json_types(data, direction=1)
return data
def test_register_type(self):
d = {"set": {1, 2, 3}}
try:
tools.json.dumps(tools.transform_json_types(d))
self.fail()
except TypeError:
pass
tools.register_type(set, (list, set))
print(tools.json.dumps(tools.transform_json_types(d)))
self.assertDictEqual(
d,
tools.transform_json_types(tools.transform_json_types(d),
direction=1))
def jsonify(status: int,
data: Union[dict, list],
need_transform=False) -> Response:
"""
make_response wrapper to JSON format
:param status:
:param data:
:param need_transform:
:return:
"""
if need_transform:
transform_json_types(data, direction=0)
resp = make_response(json_lib.dumps(data), status)
resp.mimetype = "application/json"
return resp
def gen():
global _queue
yield ServerSentEvent('INIT').encode()
for result in _queue:
if isinstance(result, dict) or isinstance(result, list):
result = json.dumps(transform_json_types(result))
yield ServerSentEvent(str(result)).encode()
def _spawn(self):
try:
resp: urllib3.HTTPResponse = self.service.session.request(
"POST",
self.service.url.path + "/transactions",
body=json.dumps({
"timeout":
self.service.timeout,
"callback-url":
f"{self.parent.self_url}/{self.parent.id}"
}),
timeout=self.service.timeout) # BLOCK, timeout
except urllib3.exceptions.HTTPError as e:
self.fail.set() # EMIT(fail)
else:
if resp.status != 200:
self.fail.set() # EMIT(fail)
else:
js = json.loads(resp.data)
transform_json_types(js, direction=1)
# TODO: validate
debug_SSE.event({
"event": "init_child_2",
"t": datetime.now(),
"data": {
"chid": self.id,
**js
}
}) # DEBUG init_child_2
self.remote_id = js["_id"]
self.key = js["transaction-key"]
self.parent.childes[self.key] = self
self.ping_timeout = js["ping-timeout"] / 1000
self.parent.threads.add(self.do_ping()) # THREAD:1, loop
self.parent.threads.add(self.wait_response()) # THREAD:1
self.parent.threads.add(self.wait_done()) # THREAD:1
def test1(self):
d = {
'date': tools.datetime.now(),
'_id': tools.ObjectId(),
'bytes': b"1234567890",
'dict': {
'_id': tools.ObjectId(),
'_id2': tools.ObjectId()
},
'list': [b"1", b"2", b"3", b"4"],
'many_dict': {
'_id': tools.ObjectId(),
'd': {
'a': 1,
'b': b'hello'
},
'd2': []
}
}
d0 = deepcopy(d)
tools.transform_json_types(d)
tools.transform_json_types(d, direction=1)
self.assertDictEqual(d0, d)
def encode(self) -> bytes:
if self.data is not None:
data = json.dumps(transform_json_types(self.data))
else:
data = " "
return bytes(str(self.header) + "\n" + data, encoding="utf-8") + b"\0"