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