iker-python-common 1.0.9__tar.gz → 1.0.10__tar.gz

{iker_python_common-1.0.9 → iker_python_common-1.0.10}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: iker-python-common
-Version: 1.0.9
+Version: 1.0.10
 Classifier: Programming Language :: Python :: 3
 Classifier: Programming Language :: Python :: 3.11
 Classifier: Programming Language :: Python :: 3.12

iker_python_common-1.0.10/src/iker/common/utils/jsonutils.py

@@ -0,0 +1,152 @@
+import math
+from collections.abc import Callable, Mapping, Sequence, Set
+from typing import Any, SupportsFloat, SupportsInt
+
+from iker.common.utils.numutils import is_normal_real
+
+__all__ = [
+    "JsonKey",
+    "JsonValue",
+    "JsonArray",
+    "JsonObject",
+    "JsonType",
+    "JsonKeyCompatible",
+    "JsonValueCompatible",
+    "JsonArrayCompatible",
+    "JsonObjectCompatible",
+    "JsonTypeCompatible",
+    "json_reformat",
+    "json_sanitize",
+    "json_compare",
+]
+
+JsonKey = str
+JsonValue = str | bool | float | int | None
+JsonObject = dict[JsonKey, "JsonType"]
+JsonArray = list["JsonType"]
+JsonType = JsonValue | JsonObject | JsonArray
+
+JsonKeyCompatible = str
+JsonValueCompatible = str | bool | SupportsFloat | SupportsInt | None
+JsonObjectCompatible = Mapping[JsonKeyCompatible, "JsonTypeCompatible"]
+JsonArrayCompatible = Sequence["JsonTypeCompatible"]
+JsonTypeCompatible = JsonValueCompatible | JsonObjectCompatible | JsonArrayCompatible
+
+
+def default_key_formatter(key: JsonKeyCompatible) -> JsonKey:
+    return str(key)
+
+
+def default_value_formatter(value: JsonValueCompatible) -> JsonValue:
+    if value is None or isinstance(value, JsonValue):
+        return value
+    if isinstance(value, SupportsFloat):
+        return float(value)
+    if isinstance(value, SupportsInt):
+        return int(value)
+    raise ValueError(f"unsupported type '{type(value)}' encountered")
+
+
+def json_reformat(
+    obj: Any,
+    key_formatter: Callable[[JsonKeyCompatible], JsonKey] = default_key_formatter,
+    value_formatter: Callable[[JsonValueCompatible], JsonType] = default_value_formatter,
+    *,
+    raise_if_unregistered: bool = True,
+    unregistered_formatter: Callable[[Any], JsonType] | None = None,
+) -> JsonType:
+    if obj is None or isinstance(obj, (JsonValue | JsonValueCompatible)):
+        return value_formatter(obj)
+    if isinstance(obj, Mapping):
+        return {key_formatter(key): json_reformat(value,
+                                                  key_formatter,
+                                                  value_formatter,
+                                                  raise_if_unregistered=raise_if_unregistered,
+                                                  unregistered_formatter=unregistered_formatter)
+                for key, value in obj.items()}
+    if isinstance(obj, Sequence):
+        return [json_reformat(item,
+                              key_formatter,
+                              value_formatter,
+                              raise_if_unregistered=raise_if_unregistered,
+                              unregistered_formatter=unregistered_formatter)
+                for item in obj]
+    if raise_if_unregistered or unregistered_formatter is None:
+        raise ValueError(f"unregistered type '{type(obj)}' encountered")
+    return unregistered_formatter(obj)
+
+
+def json_sanitize(obj: Any, *, str_inf_nan: bool = True, str_unregistered: bool = True) -> JsonType:
+    def value_formatter(value: JsonValue) -> JsonValue:
+        if isinstance(value, float) and not is_normal_real(value):
+            return str(value) if str_inf_nan else None
+        return default_value_formatter(value)
+
+    def unregistered_formatter(unregistered: Any) -> JsonType:
+        if isinstance(unregistered, Set):
+            return [json_sanitize(item, str_inf_nan=str_inf_nan, str_unregistered=str_unregistered)
+                    for item in unregistered]
+        return str(unregistered) if str_unregistered else None
+
+    return json_reformat(obj,
+                         value_formatter=value_formatter,
+                         raise_if_unregistered=False,
+                         unregistered_formatter=unregistered_formatter)
+
+
+def json_compare(
+    a: JsonType,
+    b: JsonType,
+    *,
+    int_strict: bool = False,
+    float_tol: float = 1e-5,
+    list_order: bool = True,
+    dict_extra: bool = False,
+) -> bool:
+    if a is None or b is None:
+        return a is None and b is None
+    if isinstance(a, (dict, list, str, bool)):
+        if type(a) != type(b):
+            return False
+        if isinstance(a, dict):
+            if not dict_extra and set(a.keys()) != set(b.keys()):
+                return False
+            return all(json_compare(a[k],
+                                    b[k],
+                                    int_strict=int_strict,
+                                    float_tol=float_tol,
+                                    list_order=list_order,
+                                    dict_extra=dict_extra)
+                       for k in set(a.keys()) & set(b.keys()))
+        if isinstance(a, list):
+            if len(a) != len(b):
+                return False
+            if list_order:
+                return all(json_compare(va,
+                                        vb,
+                                        int_strict=int_strict,
+                                        float_tol=float_tol,
+                                        list_order=list_order,
+                                        dict_extra=dict_extra)
+                           for va, vb in zip(a, b))
+            else:
+                return all(json_compare(va,
+                                        vb,
+                                        int_strict=int_strict,
+                                        float_tol=float_tol,
+                                        list_order=list_order,
+                                        dict_extra=dict_extra)
+                           for va, vb in zip(sorted(a), sorted(b)))
+        return a == b
+    if isinstance(a, (float, int)) and isinstance(b, (float, int)):
+        if int_strict:
+            if type(a) != type(b):
+                return False
+        if isinstance(a, float) or isinstance(b, float):
+            if math.isnan(a) and math.isnan(b):
+                return True
+            if math.isinf(a) and math.isinf(b):
+                return a == b
+            return abs(a - b) <= float_tol
+        return a == b
+    raise ValueError(f"incompatible type '{type(a)}' and '{type(b)}'")

{iker_python_common-1.0.9 → iker_python_common-1.0.10}/src/iker_python_common.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: iker-python-common
-Version: 1.0.9
+Version: 1.0.10
 Classifier: Programming Language :: Python :: 3
 Classifier: Programming Language :: Python :: 3.11
 Classifier: Programming Language :: Python :: 3.12

{iker_python_common-1.0.9 → iker_python_common-1.0.10}/src/iker_python_common.egg-info/SOURCES.txt

@@ -25,6 +25,7 @@ src/iker/common/utils/dbutils.py
 src/iker/common/utils/dockerutils.py
 src/iker/common/utils/dtutils.py
 src/iker/common/utils/funcutils.py
+src/iker/common/utils/jsonutils.py
 src/iker/common/utils/logger.py
 src/iker/common/utils/numutils.py
 src/iker/common/utils/randutils.py
@@ -50,6 +51,7 @@ test/iker_tests/common/utils/dbutils_test.py
 test/iker_tests/common/utils/dockerutils_test.py
 test/iker_tests/common/utils/dtutils_test.py
 test/iker_tests/common/utils/funcutils_test.py
+test/iker_tests/common/utils/jsonutils_test.py
 test/iker_tests/common/utils/logger_test.py
 test/iker_tests/common/utils/numutils_test.py
 test/iker_tests/common/utils/randutils_test.py

iker_python_common-1.0.10/test/iker_tests/common/utils/jsonutils_test.py

@@ -0,0 +1,504 @@
+import datetime
+import math
+import unittest
+from collections.abc import Mapping, Sequence
+from dataclasses import dataclass
+from typing import SupportsFloat, SupportsInt
+
+import ddt
+import pytest
+
+from iker.common.utils.jsonutils import json_compare, json_reformat, json_sanitize
+
+
+@dataclass(eq=True, frozen=True)
+class PrefixedStr(object):
+    prefix: str
+    value: str
+
+    def __str__(self):
+        return self.prefix + "::" + self.value
+
+
+@dataclass(eq=True, frozen=True)
+class MultipliedInt(SupportsInt):
+    value: int
+    multiplier: int = 1
+
+    def __int__(self):
+        return self.value * self.multiplier
+
+
+@dataclass(eq=True, frozen=True)
+class MultipliedFloat(SupportsFloat):
+    value: float
+    multiplier: float = 1
+
+    def __float__(self):
+        return self.value * self.multiplier
+
+
+@dataclass(frozen=True)
+class WrappedList(Sequence):
+    value: list
+
+    def __len__(self):
+        return len(self.value)
+
+    def __getitem__(self, index):
+        return self.value[index]
+
+
+@dataclass(frozen=True)
+class WrappedDict(Mapping):
+    value: dict
+
+    def __iter__(self):
+        return iter(self.value)
+
+    def __len__(self):
+        return len(self.value)
+
+    def __getitem__(self, index):
+        return self.value[index]
+
+
+@ddt.ddt
+class JsonUtilsTest(unittest.TestCase):
+
+    @ddt.data(
+        (None, None),
+        (True, True),
+        (False, False),
+        (1, 1),
+        (-1, -1),
+        (0, 0),
+        (1.0, 1.0),
+        (-1.0, -1.0),
+        (0.0, 0.0),
+        (1.0e9, 1.0e9),
+        (-1.0e-9, -1.0e-9),
+        (math.nan, math.nan),
+        (math.inf, math.inf),
+        (-math.inf, -math.inf),
+        (MultipliedInt(-1, 100), -100),
+        (MultipliedInt(1, 100), 100),
+        (MultipliedFloat(1.0, 100.0), 100.0),
+        (MultipliedFloat(-1.0, 100.0), -100.0),
+        ("", ""),
+        ("dummy", "dummy"),
+        (
+            [None, True, False, 1, -1, 0, 1.0, -1.0, 0.0, 1.0e9, -1.0e-9, math.nan, math.inf, -math.inf, "", "dummy"],
+            [None, True, False, 1, -1, 0, 1.0, -1.0, 0.0, 1.0e9, -1.0e-9, math.nan, math.inf, -math.inf, "", "dummy"],
+        ),
+        (
+            (None, True, False, 1, -1, 0, 1.0, -1.0, 0.0, 1.0e9, -1.0e-9, math.nan, math.inf, -math.inf, "", "dummy"),
+            [None, True, False, 1, -1, 0, 1.0, -1.0, 0.0, 1.0e9, -1.0e-9, math.nan, math.inf, -math.inf, "", "dummy"],
+        ),
+        (
+            {
+                "none": None,
+                "bool_true": True,
+                "bool_false": False,
+                "int_one": 1,
+                "int_minus_one": -1,
+                "int_zero": 0,
+                "int_wrapped": MultipliedInt(1, -1000),
+                "float_one": 1.0,
+                "float_minus_one": -1.0,
+                "float_zero": 0.0,
+                "float_one_e_nine": 1.0e9,
+                "float_minus_one_e_minus_nine": -1.0e-9,
+                "float_nan": math.nan,
+                "float_inf": math.inf,
+                "float_minus_inf": -math.inf,
+                "float_wrapped": MultipliedFloat(1.0, -1000.0),
+                "str_empty": "",
+                "str": "dummy",
+            },
+            {
+                "none": None,
+                "bool_true": True,
+                "bool_false": False,
+                "int_one": 1,
+                "int_minus_one": -1,
+                "int_zero": 0,
+                "int_wrapped": -1000,
+                "float_one": 1.0,
+                "float_minus_one": -1.0,
+                "float_zero": 0.0,
+                "float_one_e_nine": 1.0e9,
+                "float_minus_one_e_minus_nine": -1.0e-9,
+                "float_nan": math.nan,
+                "float_inf": math.inf,
+                "float_minus_inf": -math.inf,
+                "float_wrapped": -1000.0,
+                "str_empty": "",
+                "str": "dummy",
+            },
+        ),
+        (
+            {
+                "none": None,
+                "bool": {
+                    "bool_true": True,
+                    "bool_false": False,
+                },
+                "int": {
+                    "int_one": 1,
+                    "int_minus_one": -1,
+                    "int_zero": 0,
+                    "int_wrapped": MultipliedInt(1, -1000),
+                },
+                "float": {
+                    "float_one": 1.0,
+                    "float_minus_one": -1.0,
+                    "float_zero": 0.0,
+                    "float_one_e_nine": 1.0e9,
+                    "float_minus_one_e_minus_nine": -1.0e-9,
+                    "float_nan": math.nan,
+                    "float_inf": math.inf,
+                    "float_minus_inf": -math.inf,
+                    "float_wrapped": MultipliedFloat(1.0, -1000.0),
+                },
+                "str": {
+                    "str_empty": "",
+                    "str": "dummy",
+                },
+                "list":
+                    [None, True, False, 1, -1, 0, 1., -1., 0., 1e9, -1e-9, math.nan, math.inf, -math.inf, "", "dummy"],
+                "tuple":
+                    (None, True, False, 1, -1, 0, 1., -1., 0., 1e9, -1e-9, math.nan, math.inf, -math.inf, "", "dummy"),
+            },
+            {
+                "none": None,
+                "bool": {
+                    "bool_true": True,
+                    "bool_false": False,
+                },
+                "int": {
+                    "int_one": 1,
+                    "int_minus_one": -1,
+                    "int_zero": 0,
+                    "int_wrapped": -1000,
+                },
+                "float": {
+                    "float_one": 1.0,
+                    "float_minus_one": -1.0,
+                    "float_zero": 0.0,
+                    "float_one_e_nine": 1.0e9,
+                    "float_minus_one_e_minus_nine": -1.0e-9,
+                    "float_nan": math.nan,
+                    "float_inf": math.inf,
+                    "float_minus_inf": -math.inf,
+                    "float_wrapped": -1000.0,
+                },
+                "str": {
+                    "str_empty": "",
+                    "str": "dummy",
+                },
+                "list":
+                    [None, True, False, 1, -1, 0, 1., -1., 0., 1e9, -1e-9, math.nan, math.inf, -math.inf, "", "dummy"],
+                "tuple":
+                    [None, True, False, 1, -1, 0, 1., -1., 0., 1e9, -1e-9, math.nan, math.inf, -math.inf, "", "dummy"],
+            },
+        ),
+        (
+            WrappedDict({
+                PrefixedStr("key", "none"): None,
+                PrefixedStr("key", "bool"): WrappedDict({
+                    PrefixedStr("key", "bool_true"): True,
+                    PrefixedStr("key", "bool_false"): False,
+                }),
+                PrefixedStr("key", "int"): WrappedDict({
+                    PrefixedStr("key", "int_one"): 1,
+                    PrefixedStr("key", "int_minus_one"): -1,
+                    PrefixedStr("key", "int_zero"): 0,
+                    PrefixedStr("key", "int_wrapped"): MultipliedInt(1, -1000),
+                }),
+                PrefixedStr("key", "float"): WrappedDict({
+                    PrefixedStr("key", "float_one"): 1.0,
+                    PrefixedStr("key", "float_minus_one"): -1.0,
+                    PrefixedStr("key", "float_zero"): 0.0,
+                    PrefixedStr("key", "float_one_e_nine"): 1.0e9,
+                    PrefixedStr("key", "float_minus_one_e_minus_nine"): -1.0e-9,
+                    PrefixedStr("key", "float_nan"): math.nan,
+                    PrefixedStr("key", "float_inf"): math.inf,
+                    PrefixedStr("key", "float_minus_inf"): -math.inf,
+                    PrefixedStr("key", "float_wrapped"): MultipliedFloat(1.0, -1000.0),
+                }),
+                PrefixedStr("key", "str"): WrappedDict({
+                    PrefixedStr("key", "str_empty"): "",
+                    PrefixedStr("key", "str"): "dummy",
+                }),
+                PrefixedStr("key", "list"): WrappedList(
+                    [None, True, False, 1, -1, 0, 1., -1., 0., 1e9, -1e-9, math.nan, math.inf, -math.inf, "", "dummy"]),
+                PrefixedStr("key", "tuple"):
+                    (None, True, False, 1, -1, 0, 1., -1., 0., 1e9, -1e-9, math.nan, math.inf, -math.inf, "", "dummy"),
+            }),
+            {
+                "key::none": None,
+                "key::bool": {
+                    "key::bool_true": True,
+                    "key::bool_false": False,
+                },
+                "key::int": {
+                    "key::int_one": 1,
+                    "key::int_minus_one": -1,
+                    "key::int_zero": 0,
+                    "key::int_wrapped": -1000,
+                },
+                "key::float": {
+                    "key::float_one": 1.0,
+                    "key::float_minus_one": -1.0,
+                    "key::float_zero": 0.0,
+                    "key::float_one_e_nine": 1.0e9,
+                    "key::float_minus_one_e_minus_nine": -1.0e-9,
+                    "key::float_nan": math.nan,
+                    "key::float_inf": math.inf,
+                    "key::float_minus_inf": -math.inf,
+                    "key::float_wrapped": -1000.0,
+                },
+                "key::str": {
+                    "key::str_empty": "",
+                    "key::str": "dummy",
+                },
+                "key::list":
+                    [None, True, False, 1, -1, 0, 1., -1., 0., 1e9, -1e-9, math.nan, math.inf, -math.inf, "", "dummy"],
+                "key::tuple":
+                    [None, True, False, 1, -1, 0, 1., -1., 0., 1e9, -1e-9, math.nan, math.inf, -math.inf, "", "dummy"],
+            },
+        ),
+    )
+    @ddt.unpack
+    def test_json_reformat(self, data, expect):
+        self.assertTrue(json_compare(json_reformat(data), expect))
+
+    @ddt.data(
+        (set(),),
+        (object(),),
+        ([set(), object()],),
+        ({"set": set(), "object": object()},),
+    )
+    def test_json_reformat__unregistered_type(self, data):
+        with pytest.raises(ValueError):
+            json_reformat(data)
+
+    @ddt.data(
+        (None, None),
+        (True, True),
+        (False, False),
+        (1, 1),
+        (-1, -1),
+        (0, 0),
+        (1.0, 1.0),
+        (-1.0, -1.0),
+        (0.0, 0.0),
+        (1.0e9, 1.0e9),
+        (-1.0e-9, -1.0e-9),
+        (math.nan, "nan"),
+        (math.inf, "inf"),
+        (-math.inf, "-inf"),
+        (MultipliedInt(-1, 100), -100),
+        (MultipliedInt(1, 100), 100),
+        (MultipliedFloat(1.0, 100.0), 100.0),
+        (MultipliedFloat(-1.0, 100.0), -100.0),
+        ("", ""),
+        ("dummy", "dummy"),
+        (
+            datetime.datetime(2000, 1, 1, 0, 0, 0, tzinfo=datetime.timezone.utc),
+            "2000-01-01 00:00:00+00:00",
+        ),
+        (
+            [None, True, False, 1, -1, 0, 1.0, -1.0, 0.0, 1.0e9, -1.0e-9, math.nan, math.inf, -math.inf, "", "dummy"],
+            [None, True, False, 1, -1, 0, 1.0, -1.0, 0.0, 1.0e9, -1.0e-9, "nan", "inf", "-inf", "", "dummy"],
+        ),
+        (
+            (None, True, False, 1, -1, 0, 1.0, -1.0, 0.0, 1.0e9, -1.0e-9, math.nan, math.inf, -math.inf, "", "dummy"),
+            [None, True, False, 1, -1, 0, 1.0, -1.0, 0.0, 1.0e9, -1.0e-9, "nan", "inf", "-inf", "", "dummy"],
+        ),
+        ({1, 2, 3, 4, 5, 6, 7}, [1, 2, 3, 4, 5, 6, 7]),
+        (
+            {
+                "none": None,
+                "bool_true": True,
+                "bool_false": False,
+                "int_one": 1,
+                "int_minus_one": -1,
+                "int_zero": 0,
+                "int_wrapped": MultipliedInt(1, -1000),
+                "float_one": 1.0,
+                "float_minus_one": -1.0,
+                "float_zero": 0.0,
+                "float_one_e_nine": 1.0e9,
+                "float_minus_one_e_minus_nine": -1.0e-9,
+                "float_nan": math.nan,
+                "float_inf": math.inf,
+                "float_minus_inf": -math.inf,
+                "float_wrapped": MultipliedFloat(1.0, -1000.0),
+                "str_empty": "",
+                "str": "dummy",
+                "datetime": datetime.datetime(2000, 1, 1, 0, 0, 0, tzinfo=datetime.timezone.utc),
+            },
+            {
+                "none": None,
+                "bool_true": True,
+                "bool_false": False,
+                "int_one": 1,
+                "int_minus_one": -1,
+                "int_zero": 0,
+                "int_wrapped": -1000,
+                "float_one": 1.0,
+                "float_minus_one": -1.0,
+                "float_zero": 0.0,
+                "float_one_e_nine": 1.0e9,
+                "float_minus_one_e_minus_nine": -1.0e-9,
+                "float_nan": "nan",
+                "float_inf": "inf",
+                "float_minus_inf": "-inf",
+                "float_wrapped": -1000.0,
+                "str_empty": "",
+                "str": "dummy",
+                "datetime": "2000-01-01 00:00:00+00:00",
+            },
+        ),
+        (
+            {
+                "none": None,
+                "bool": {
+                    "bool_true": True,
+                    "bool_false": False,
+                },
+                "int": {
+                    "int_one": 1,
+                    "int_minus_one": -1,
+                    "int_zero": 0,
+                    "int_wrapped": MultipliedInt(1, -1000),
+                },
+                "float": {
+                    "float_one": 1.0,
+                    "float_minus_one": -1.0,
+                    "float_zero": 0.0,
+                    "float_one_e_nine": 1.0e9,
+                    "float_minus_one_e_minus_nine": -1.0e-9,
+                    "float_nan": math.nan,
+                    "float_inf": math.inf,
+                    "float_minus_inf": -math.inf,
+                    "float_wrapped": MultipliedFloat(1.0, -1000.0),
+                },
+                "str": {
+                    "str_empty": "",
+                    "str": "dummy",
+                },
+                "datetime": datetime.datetime(2000, 1, 1, 0, 0, 0, tzinfo=datetime.timezone.utc),
+                "list":
+                    [None, True, False, 1, -1, 0, 1., -1., 0., 1e9, -1e-9, math.nan, math.inf, -math.inf, "", "dummy"],
+                "tuple":
+                    (None, True, False, 1, -1, 0, 1., -1., 0., 1e9, -1e-9, math.nan, math.inf, -math.inf, "", "dummy"),
+                "set": {1, 2, 3, 4, 5, 6, 7},
+            },
+            {
+                "none": None,
+                "bool": {
+                    "bool_true": True,
+                    "bool_false": False,
+                },
+                "int": {
+                    "int_one": 1,
+                    "int_minus_one": -1,
+                    "int_zero": 0,
+                    "int_wrapped": -1000,
+                },
+                "float": {
+                    "float_one": 1.0,
+                    "float_minus_one": -1.0,
+                    "float_zero": 0.0,
+                    "float_one_e_nine": 1.0e9,
+                    "float_minus_one_e_minus_nine": -1.0e-9,
+                    "float_nan": "nan",
+                    "float_inf": "inf",
+                    "float_minus_inf": "-inf",
+                    "float_wrapped": -1000.0,
+                },
+                "str": {
+                    "str_empty": "",
+                    "str": "dummy",
+                },
+                "datetime": "2000-01-01 00:00:00+00:00",
+                "list": [None, True, False, 1, -1, 0, 1., -1., 0., 1e9, -1e-9, "nan", "inf", "-inf", "", "dummy"],
+                "tuple": [None, True, False, 1, -1, 0, 1., -1., 0., 1e9, -1e-9, "nan", "inf", "-inf", "", "dummy"],
+                "set": [1, 2, 3, 4, 5, 6, 7],
+            },
+        ),
+        (
+            WrappedDict({
+                PrefixedStr("key", "none"): None,
+                PrefixedStr("key", "bool"): WrappedDict({
+                    PrefixedStr("key", "bool_true"): True,
+                    PrefixedStr("key", "bool_false"): False,
+                }),
+                PrefixedStr("key", "int"): WrappedDict({
+                    PrefixedStr("key", "int_one"): 1,
+                    PrefixedStr("key", "int_minus_one"): -1,
+                    PrefixedStr("key", "int_zero"): 0,
+                    PrefixedStr("key", "int_wrapped"): MultipliedInt(1, -1000),
+                }),
+                PrefixedStr("key", "float"): WrappedDict({
+                    PrefixedStr("key", "float_one"): 1.0,
+                    PrefixedStr("key", "float_minus_one"): -1.0,
+                    PrefixedStr("key", "float_zero"): 0.0,
+                    PrefixedStr("key", "float_one_e_nine"): 1.0e9,
+                    PrefixedStr("key", "float_minus_one_e_minus_nine"): -1.0e-9,
+                    PrefixedStr("key", "float_nan"): math.nan,
+                    PrefixedStr("key", "float_inf"): math.inf,
+                    PrefixedStr("key", "float_minus_inf"): -math.inf,
+                    PrefixedStr("key", "float_wrapped"): MultipliedFloat(1.0, -1000.0),
+                }),
+                PrefixedStr("key", "str"): WrappedDict({
+                    PrefixedStr("key", "str_empty"): "",
+                    PrefixedStr("key", "str"): "dummy",
+                }),
+                PrefixedStr("key", "datetime"): datetime.datetime(2000, 1, 1, 0, 0, 0, tzinfo=datetime.timezone.utc),
+                PrefixedStr("key", "list"): WrappedList(
+                    [None, True, False, 1, -1, 0, 1., -1., 0., 1e9, -1e-9, math.nan, math.inf, -math.inf, "", "dummy"]),
+                PrefixedStr("key", "tuple"):
+                    (None, True, False, 1, -1, 0, 1., -1., 0., 1e9, -1e-9, math.nan, math.inf, -math.inf, "", "dummy"),
+                PrefixedStr("key", "set"): {1, 2, 3, 4, 5, 6, 7},
+            }),
+            {
+                "key::none": None,
+                "key::bool": {
+                    "key::bool_true": True,
+                    "key::bool_false": False,
+                },
+                "key::int": {
+                    "key::int_one": 1,
+                    "key::int_minus_one": -1,
+                    "key::int_zero": 0,
+                    "key::int_wrapped": -1000,
+                },
+                "key::float": {
+                    "key::float_one": 1.0,
+                    "key::float_minus_one": -1.0,
+                    "key::float_zero": 0.0,
+                    "key::float_one_e_nine": 1.0e9,
+                    "key::float_minus_one_e_minus_nine": -1.0e-9,
+                    "key::float_nan": "nan",
+                    "key::float_inf": "inf",
+                    "key::float_minus_inf": "-inf",
+                    "key::float_wrapped": -1000.0,
+                },
+                "key::str": {
+                    "key::str_empty": "",
+                    "key::str": "dummy",
+                },
+                "key::datetime": "2000-01-01 00:00:00+00:00",
+                "key::list": [None, True, False, 1, -1, 0, 1., -1., 0., 1e9, -1e-9, "nan", "inf", "-inf", "", "dummy"],
+                "key::tuple": [None, True, False, 1, -1, 0, 1., -1., 0., 1e9, -1e-9, "nan", "inf", "-inf", "", "dummy"],
+                "key::set": [1, 2, 3, 4, 5, 6, 7],
+            },
+        ),
+    )
+    @ddt.unpack
+    def test_json_sanitize(self, data, expect):
+        self.assertTrue(json_compare(json_sanitize(data), expect))