def test_to_json_obj_large_collections_namedtuple():
class Pair(NamedTuple):
left: int
right: int
large_list: List[Pair] = []
large_list_encoding_lists: List[list] = []
large_list_encoding_dicts: List[dict] = []
for i in range(1000):
large_list.append(Pair(i, i+1))
large_list_encoding_lists.append([i, i+1])
large_list_encoding_dicts.append({"left": i, "right": i+1})
assert to_json_obj(large_list, List[Pair], namedtuples_as_lists=True) == large_list_encoding_lists
assert to_json_obj(large_list, List[Pair], namedtuples_as_lists=False) == large_list_encoding_dicts
def test_from_json_obj_large_collections_namedtuple():
class Pair(NamedTuple):
left: int
right: int
large_list: List[Pair] = []
for i in range(1000):
large_list.append(Pair(i, i + 1))
assert from_json_obj(
to_json_obj(large_list, List[Pair], namedtuples_as_lists=False),
List[Pair]) == large_list
assert from_json_obj(
to_json_obj(large_list, List[Pair], namedtuples_as_lists=True),
List[Pair]) == large_list
def dumps(obj: Any,
encoded_type: Type,
skipkeys=False,
ensure_ascii=True,
check_circular=True,
allow_nan=True,
cls=None,
indent=None,
separators=None,
default=None,
sort_keys=False,
**kw) -> str:
# pylint: disable = too-many-arguments
"""
Encodes `obj` as a JSON object using `encoded_type` as a type hint, then calls `json.dumps`.
Raises `TypeError` is `encoded_type` is not JSON-encodable according to `typing_json.encoding.is_json_encodable`.
"""
if not is_json_encodable(encoded_type):
raise TypeError("Type %s is not json-encodable." % str(encoded_type))
json_obj = to_json_obj(obj, encoded_type)
return json.dumps(json_obj,
skipkeys=skipkeys,
ensure_ascii=ensure_ascii,
check_circular=check_circular,
allow_nan=allow_nan,
cls=cls,
indent=indent,
separators=separators,
default=default,
sort_keys=sort_keys,
**kw)
def test_to_json_obj_sequences():
""" Checks that sequences are encoded into lists with the correct elements. """
def _assert_eq_lists(l1, l2):
assert isinstance(l1, list)
assert isinstance(l2, list)
assert len(l1) == len(l2)
assert all(l1[i] == l2[i] for i in range(len(l1)))
assert all(type(l1[i]) == type(l2[i]) for i in range(len(l1)))
for val, t, encoding in SEQUENCES_ENCODINGS:
_assert_eq_lists(to_json_obj(val, t), encoding)
def test_is_json_encodable_namedtuple():
"""
Tests the encoding of namedtuples.
"""
class NamedTupleExampleT(NamedTuple):
name: str
value: Union[int, float]
t = NamedTupleExampleT("t", 1)
t_encoding = OrderedDict([("name", "t"), ("value", 1)])
assert to_json_obj(t, NamedTupleExampleT) == t_encoding
def test_to_json_obj_typeerrors():
""" Checks that `to_json_obj` raises `TypeError` on non-typecheckable types and when `obj` is not an instance of `t`.
"""
class NonTypechekableT:
name: str
val: int
def __init__(self, name, val):
self.name = name
self.val = val
x = NonTypechekableT("x", 0)
try:
to_json_obj(x, NonTypechekableT)
assert False
except TypeError:
assert True
try:
to_json_obj(0, str)
assert False
except TypeError:
assert True
def test_to_json_obj_large_collections_none():
large_list: List[None] = []
for i in range(1000):
large_list.append(None)
assert to_json_obj(large_list, List[None]) == large_list
assert to_json_obj(large_list, List[type(None)]) == large_list
def test_to_json_obj_enums():
assert to_json_obj(EnumT.Red, EnumT) == "Red"
def test_to_json_obj_basetypes():
""" Test `to_json_obj` on JSON base types and `decimal.Decimal`. """
for val, t, encoding in BASETYPES_ENCODINGS:
assert to_json_obj(val, t) == encoding
assert to_json_obj(Decimal("1.5"), Decimal, use_decimal=True) == Decimal("1.5")
def test_to_json_typed_dict():
class Pair(TypedDict):
left: int
right: int
assert to_json_obj({"left": 0, "right": 1}, Pair) == {"left": 0, "right": 1}
def test_to_json_obj_sets():
""" Checks that sets are encoded into lists with the correct elements. """
for val, t, encoding in SETS_ENCODINGS:
to_json_obj(val, t) == encoding
def test_to_json_obj_large_collections_other():
large_list: List[Tuple[int, int]] = []
for i in range(1000):
large_list.append((i, i+1))
assert to_json_obj(large_list, List[Tuple[int, int]]) == [list(el) for el in large_list]
def test_to_json_obj_dicts():
""" Checks that dicts/mappings are encoded into dicts with the correct key/value pairs. """
for val, t, encoding in DICT_ENCODINGS:
to_json_obj(val, t) == encoding
def test_from_json_obj():
# pylint:disable=missing-docstring,invalid-name
for t in BASE_TYPES:
obj = BASE_TYPES[t]
if t is ...:
assert from_json_obj(to_json_obj(obj, t), t) is ...
else:
assert from_json_obj(to_json_obj(obj, t), t) is obj
assert from_json_obj(to_json_obj(None, None), None) is None
class A(NamedTuple):
name: str
value: int
a = A("hi", 0)
# pylint:disable=line-too-long
assert from_json_obj(to_json_obj(a, A), A) == a
assert from_json_obj(["hi", 0], A) == a
a._field_defaults["value"] = 0 # type:ignore #pylint:disable=no-member,protected-access
assert from_json_obj({"name": "hi"}, A) == a
assert from_json_obj(to_json_obj(1, Union[int, float]), Union[int,
float]) == 1
assert from_json_obj(to_json_obj(1.0, Union[int, float]),
Union[int, float]) == 1.0
assert from_json_obj(to_json_obj("hi", Literal["hi", 1]),
Literal["hi", 1]) == "hi"
assert from_json_obj(to_json_obj(1, Literal["hi", 1]), Literal["hi",
1]) == 1
assert from_json_obj(to_json_obj(["hi", "my"], List[str]),
List[str]) == ["hi", "my"]
assert from_json_obj(to_json_obj(set(["hi", "my"]), Set[str]),
Set[str]) == set(["hi", "my"])
assert from_json_obj(to_json_obj(deque(["hi", "my"]), Deque[str]),
Deque[str]) == deque(["hi", "my"])
assert from_json_obj(to_json_obj(frozenset(["hi", "my"]), FrozenSet[str]),
FrozenSet[str]) == frozenset(["hi", "my"])
assert from_json_obj(to_json_obj(tuple(["hi", "my"]), Tuple[str, ...]),
Tuple[str, ...]) == tuple(["hi", "my"])
assert from_json_obj(to_json_obj(tuple(["hi", 0]), Tuple[str, int]),
Tuple[str, int]) == tuple(["hi", 0])
d = {"name": "hi", "value": "zero"}
assert from_json_obj(to_json_obj(d, Dict[str, str]), Dict[str, str]) == d
od = collections.OrderedDict(d)
assert from_json_obj(to_json_obj(od, typing.OrderedDict[str, str]),
typing.OrderedDict[str, str]) == od
def test_to_json_obj_large_collections_decimal():
large_list: List[Decimal] = []
for i in range(1000):
large_list.append(Decimal(i))
assert to_json_obj(large_list, List[Decimal], use_decimal=True) == large_list
assert to_json_obj(large_list, List[Decimal], use_decimal=False) == [str(el) for el in large_list]
def test_to_json_obj_large_collections_int():
large_list: List[int] = []
for i in range(1000):
large_list.append(i)
assert to_json_obj(large_list, List[int]) == large_list
def test_to_json_obj_ordereddicts():
""" Checks that dicts/mappings are encoded into dicts with the correct key/value pairs. """
for val, t, encoding in ORDERED_DICT_ENCODINGS:
assert to_json_obj(val, t) == encoding
def test_to_json_obj_large_collections_enum():
large_list: List[EnumT] = []
for i in range(1000):
large_list.append(EnumT.Red)
assert to_json_obj(large_list, List[EnumT]) == ["Red" for _ in large_list]
def test_to_json_obj():
# pylint:disable=missing-docstring,invalid-name
try:
to_json_obj(1.0j, complex)
assert False
except TypeError:
assert True
try:
to_json_obj("hi", int)
assert False
except TypeError:
assert True
for t in BASE_TYPES:
obj = BASE_TYPES[t]
if t is ...:
assert to_json_obj(obj, t) is None
else:
assert to_json_obj(obj, t) is obj
class A(NamedTuple):
name: str
value: int
a = A("hi", 0)
assert to_json_obj(a, A) == {"name": "hi", "value": 0}
assert to_json_obj(1, Union[int, float]) == 1
assert to_json_obj(1.0, Union[int, float]) == 1.0
assert to_json_obj("hi", Literal["hi", 1]) == "hi"
assert to_json_obj(1, Literal["hi", 1]) == 1
assert to_json_obj(["hi", "my"], List[str]) == ["hi", "my"]
set_example = to_json_obj(set(["hi", "my"]), Set[str])
assert isinstance(set_example, list)
assert set(set_example) == set(["hi", "my"])
frozenset_example = to_json_obj(frozenset(["hi", "my"]), FrozenSet[str])
assert isinstance(frozenset_example, list)
assert frozenset(frozenset_example) == frozenset(["hi", "my"])
assert to_json_obj(tuple(["hi", "my"]), Tuple[str, ...]) == ["hi", "my"]
assert to_json_obj(tuple(["hi", 0]), Tuple[str, int]) == ["hi", 0]
d = {"name": "hi", "value": "zero"}
assert to_json_obj(d, Dict[str, str]) == d
od = collections.OrderedDict()
od["value"] = "zero"
od["name"] = "hi"
assert to_json_obj(od, typing.OrderedDict[str, str]) == od
