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

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

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

{iker_python_common-1.0.10 → iker_python_common-1.0.11}/src/iker/common/utils/jsonutils.py

@@ -15,6 +15,8 @@ __all__ = [
     "JsonArrayCompatible",
     "JsonObjectCompatible",
     "JsonTypeCompatible",
+    "NodePath",
+    "json_traverse",
     "json_reformat",
     "json_sanitize",
     "json_compare",
@@ -32,6 +34,65 @@ JsonObjectCompatible = Mapping[JsonKeyCompatible, "JsonTypeCompatible"]
 JsonArrayCompatible = Sequence["JsonTypeCompatible"]
 JsonTypeCompatible = JsonValueCompatible | JsonObjectCompatible | JsonArrayCompatible
 
+NodePath = list[str | int]
+
+
+def default_key_visitor(node_path: NodePath, key: JsonKeyCompatible) -> JsonKey:
+    return str(key)
+
+
+def default_value_visitor(node_path: NodePath, 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 default_object_visitor(node_path: NodePath, old_object: JsonObjectCompatible, new_object: JsonObject) -> JsonType:
+    return new_object
+
+
+def default_array_visitor(node_path: NodePath, old_array: JsonArrayCompatible, new_array: JsonArray) -> JsonType:
+    return new_array
+
+
+def json_traverse(
+    obj: Any,
+    key_visitor: Callable[[NodePath, JsonKeyCompatible], JsonKey] = default_key_visitor,
+    value_visitor: Callable[[NodePath, JsonValueCompatible], JsonType] = default_value_visitor,
+    object_visitor: Callable[[NodePath, JsonObjectCompatible, JsonObject], JsonType] = default_object_visitor,
+    array_visitor: Callable[[NodePath, JsonArrayCompatible, JsonArray], JsonType] = default_array_visitor,
+    stop_func: Callable[[NodePath], bool] = lambda x: False,
+    *,
+    raise_if_unregistered: bool = True,
+    unregistered_visitor: Callable[[NodePath, Any], JsonType] | None = None,
+) -> JsonType:
+    def func(obj: Any, node_path: NodePath):
+        if stop_func(node_path):
+            return None
+        if obj is None or isinstance(obj, (JsonValue | JsonValueCompatible)):
+            return value_visitor(node_path, obj)
+        if isinstance(obj, Mapping):
+            return object_visitor(
+                node_path,
+                obj,
+                {key_visitor(node_path, key): func(value, node_path + [key]) for key, value in obj.items()},
+            )
+        if isinstance(obj, Sequence):
+            return array_visitor(
+                node_path,
+                obj,
+                [func(item, node_path + [index]) for index, item in enumerate(obj)],
+            )
+        if raise_if_unregistered or unregistered_visitor is None:
+            raise ValueError(f"unregistered type '{type(obj)}' encountered")
+        return unregistered_visitor(node_path, obj)
+
+    return func(obj, [])
+
 
 def default_key_formatter(key: JsonKeyCompatible) -> JsonKey:
     return str(key)
@@ -55,25 +116,20 @@ def json_reformat(
     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 key_visitor(node_path: NodePath, key: JsonKeyCompatible) -> JsonKey:
+        return key_formatter(key)
+
+    def value_visitor(node_path: NodePath, value: JsonValueCompatible) -> JsonType:
+        return value_formatter(value)
+
+    def unregistered_visitor(node_path: NodePath, obj: Any) -> JsonType:
+        return unregistered_formatter(obj) if unregistered_formatter is not None else None
+
+    return json_traverse(obj,
+                         key_visitor=key_visitor,
+                         value_visitor=value_visitor,
+                         raise_if_unregistered=raise_if_unregistered,
+                         unregistered_visitor=unregistered_visitor)
 
 
 def json_sanitize(obj: Any, *, str_inf_nan: bool = True, str_unregistered: bool = True) -> JsonType:

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

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

{iker_python_common-1.0.10 → iker_python_common-1.0.11}/test/iker_tests/common/utils/jsonutils_test.py

@@ -8,7 +8,7 @@ from typing import SupportsFloat, SupportsInt
 import ddt
 import pytest
 
-from iker.common.utils.jsonutils import json_compare, json_reformat, json_sanitize
+from iker.common.utils.jsonutils import json_compare, json_reformat, json_sanitize, json_traverse
 
 
 @dataclass(eq=True, frozen=True)
@@ -271,6 +271,307 @@ class JsonUtilsTest(unittest.TestCase):
         ),
     )
     @ddt.unpack
+    def test_json_traverse(self, data, expect):
+        self.assertTrue(json_compare(json_traverse(data), expect))
+
+    def test_json_traverse__object_array_visitor(self):
+        data = {
+            "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"),
+        }
+
+        expect = {
+            "none": None,
+            "bool": {
+                "bool_true": True,
+                "bool_false": False,
+            },
+            "int": {
+                "int_one": 1,
+                "int_minus_one": -1,
+                "int_zero": 0,
+                "int_wrapped": None,
+            },
+            "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": None,
+            },
+            "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"]
+                + [None, True, False, 1, -1, 0, 1., -1., 0., 1e9, -1e-9, None, 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, True, False, 1, -1, 0, 1., -1., 0., 1e9, -1e-9, None, math.inf, -math.inf, "", "dummy"],
+        }
+
+        def object_visitor(node_path, old_object, new_object):
+            if node_path == ["str"]:
+                return [[key, value] for key, value in new_object.items()]
+            return new_object
+
+        def array_visitor(node_path, old_array, new_array):
+            return list(old_array) + list(new_array)
+
+        def stop_func(node_path) -> bool:
+            return node_path in (
+                ["int", "int_wrapped"],
+                ["float", "float_wrapped"],
+                ["list", 11],
+                ["tuple", 11],
+                [0],
+                ["dummy"],
+            )
+
+        self.assertTrue(json_compare(json_traverse(data,
+                                                   object_visitor=object_visitor,
+                                                   array_visitor=array_visitor,
+                                                   stop_func=stop_func),
+                                     expect))
+
+    @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))