iker-python-common 1.0.63__tar.gz → 1.0.64__tar.gz

{iker_python_common-1.0.63 → iker_python_common-1.0.64}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: iker-python-common
-Version: 1.0.63
+Version: 1.0.64
 Classifier: Programming Language :: Python :: 3
 Classifier: Programming Language :: Python :: 3.12
 Classifier: Programming Language :: Python :: 3.13

iker_python_common-1.0.63/src/iker/common/utils/sequtils.py → iker_python_common-1.0.64/src/iker/common/utils/iterutils.py

@@ -27,6 +27,15 @@ __all__ = [
     "chunk_between",
     "chunk_with_key",
     "merge_chunks",
+    "dicttree",
+    "dicttree_value",
+    "dicttree_subtree",
+    "dicttree_children",
+    "dicttree_lineage",
+    "dicttree_make",
+    "dicttree_add",
+    "dicttree_remove",
+    "dicttree_purge",
     "Seq",
     "seq",
 ]
@@ -539,6 +548,165 @@ def merge_chunks[T](
                    chunk_between(chunks, lambda a, b: not merge_func(a, b)))
 
 
+# Dicttree, a tree structure implemented using nested dictionaries,
+# where each node can have an optional value and child nodes.
+type dicttree[K, V] = dict[K, tuple[V | None, dicttree[K, V]]]
+
+
+def dicttree_value[K, V](tree: dicttree[K, V], path: list[K]) -> V | None:
+    """
+    Gets the value stored at the specified path in the dicttree.
+
+    :param tree: the dicttree to retrieve the value from.
+    :param path: the list of keys representing the path to the desired value.
+    :return: the value at the specified path, or ``None`` if the path does not exist.
+    """
+    value = None
+    for key in path:
+        if key not in tree:
+            return None
+        value, tree = tree[key]
+    return value
+
+
+def dicttree_subtree[K, V](tree: dicttree[K, V], path: list[K]) -> dicttree[K, V] | None:
+    """
+    Gets the subtree located at the specified path in the dicttree.
+
+    :param tree: the dicttree to retrieve the subtree from.
+    :param path: the list of keys representing the path to the desired subtree.
+    :return: the subtree at the specified path, or ``None`` if the path does not exist.
+    """
+    for key in path:
+        if key not in tree:
+            return None
+        _, tree = tree[key]
+    return tree
+
+
+def dicttree_children[K, V](tree: dicttree[K, V], *, leaves_only: bool = False) -> Generator[V, None, None]:
+    """
+    Yields all values in the dicttree. If ``leaves_only`` is ``True``, only yields values at leaf nodes.
+
+    :param tree: the dicttree to traverse.
+    :param leaves_only: whether to yield only values at leaf nodes.
+    :return: a generator yielding all values in the dicttree.
+    """
+    for value, subtree in tree.values():
+        if value is not None and (not leaves_only or not subtree):
+            yield value
+        yield from dicttree_children(subtree, leaves_only=leaves_only)
+
+
+def dicttree_lineage[K, V](tree: dicttree[K, V], path: list[K]) -> Generator[V, None, None]:
+    """
+    Yields all values along the specified path in the dicttree.
+
+    :param tree: the dicttree to traverse.
+    :param path: the list of keys representing the path to follow.
+    :return: a generator yielding all values along the specified path.
+    """
+    for key in path:
+        if key not in tree:
+            return
+        value, tree = tree[key]
+        if value is not None:
+            yield value
+
+
+def dicttree_make[K, V](tree: dicttree[K, V], path: list[K]) -> dicttree[K, V]:
+    """
+    Ensures that the specified path exists in the dicttree, creating any missing nodes along the way.
+
+    :param tree: the dicttree to modify.
+    :param path: the list of keys representing the path to create.
+    :return: the subtree at the end of the created path.
+    """
+    for key in path:
+        tree.setdefault(key, (None, {}))
+        _, tree = tree[key]
+    return tree
+
+
+def dicttree_add[K, V](
+    tree: dicttree[K, V],
+    path: list[K],
+    value: V,
+    *,
+    create_prefix: bool = True,
+    overwrite: bool = False,
+) -> dicttree[K, V]:
+    """
+    Adds a value at the specified path in the dicttree. If ``create_prefix`` is ``True``, any missing nodes along the
+    path are created. If ``overwrite`` is ``False``, raises an error if the path already exists.
+
+    :param tree: the dicttree to modify.
+    :param path: the list of keys representing the path to add the value to.
+    :param value: the value to add at the specified path.
+    :param create_prefix: whether to create missing nodes along the path.
+    :param overwrite: whether to overwrite an existing value at the path.
+    :return: the modified dicttree.
+    """
+    if len(path) == 0:
+        raise ValueError("path cannot be empty")
+    *prefix, key = path
+    if create_prefix:
+        subtree = dicttree_make(tree, prefix)
+    else:
+        subtree = dicttree_subtree(tree, prefix)
+        if subtree is None:
+            raise ValueError("prefix path does not exist in dicttree")
+    if not overwrite and dicttree_value(subtree, [key]) is not None:
+        raise ValueError("path already exists in dicttree")
+    else:
+        subtree[key] = (value, dicttree_subtree(subtree, [key]) or {})
+    return tree
+
+
+def dicttree_remove[K, V](
+    tree: dicttree[K, V],
+    path: list[K],
+    *,
+    recursive: bool = False,
+) -> dicttree[K, V]:
+    """
+    Removes the value at the specified path in the dicttree. If ``recursive`` is ``True``, removes the entire subtree
+    at that path; otherwise, only removes the value, leaving any child nodes intact.
+
+    :param tree: the dicttree to modify.
+    :param path: the list of keys representing the path to remove the value from.
+    :param recursive: whether to remove the entire subtree at the path.
+    :return: the modified dicttree.
+    """
+    if len(path) == 0:
+        raise ValueError("path cannot be empty")
+    *prefix, key = path
+    subtree = dicttree_subtree(tree, prefix)
+    if subtree is None:
+        raise ValueError("prefix path does not exist in dicttree")
+    if dicttree_value(subtree, [key]) is None:
+        raise ValueError("path does not exist in dicttree")
+    else:
+        subtree[key] = (None, {} if recursive else dicttree_subtree(subtree, [key]) or {})
+    return tree
+
+
+def dicttree_purge[K, V](tree: dicttree[K, V]) -> dicttree[K, V]:
+    """
+    Recursively removes all nodes in the dicttree that have no value and no children.
+
+    :param tree: the dicttree to purge.
+    :return: the purged dicttree.
+    """
+    for key in list(tree.keys()):
+        value, subtree = tree[key]
+        dicttree_purge(subtree)
+        if subtree or value is not None:
+            continue
+        del tree[key]
+    return tree
+
+
 class Seq[T](Sequence[T], Sized):
     def __init__(self, data: Iterable[T]):
         if isinstance(data, Seq):

{iker_python_common-1.0.63 → iker_python_common-1.0.64}/src/iker/common/utils/randutils.py

@@ -8,8 +8,8 @@ from typing import overload
 
 from iker.common.utils.dtutils import dt_utc_max, dt_utc_min
 from iker.common.utils.funcutils import memorized, singleton
+from iker.common.utils.iterutils import head_or_none
 from iker.common.utils.jsonutils import JsonType
-from iker.common.utils.sequtils import head_or_none
 
 __all__ = [
     "max_int",

{iker_python_common-1.0.63 → iker_python_common-1.0.64}/src/iker/common/utils/shutils.py

@@ -4,7 +4,7 @@ import shutil
 from typing import Protocol
 
 from iker.common.utils import logger
-from iker.common.utils.sequtils import last, last_or_none, tail_iter
+from iker.common.utils.iterutils import last, last_or_none, tail_iter
 from iker.common.utils.strutils import is_empty
 
 __all__ = [

{iker_python_common-1.0.63 → iker_python_common-1.0.64}/src/iker_python_common.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: iker-python-common
-Version: 1.0.63
+Version: 1.0.64
 Classifier: Programming Language :: Python :: 3
 Classifier: Programming Language :: Python :: 3.12
 Classifier: Programming Language :: Python :: 3.13

{iker_python_common-1.0.63 → iker_python_common-1.0.64}/src/iker_python_common.egg-info/SOURCES.txt

@@ -28,12 +28,12 @@ src/iker/common/utils/csv.py
 src/iker/common/utils/dbutils.py
 src/iker/common/utils/dtutils.py
 src/iker/common/utils/funcutils.py
+src/iker/common/utils/iterutils.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
 src/iker/common/utils/retry.py
-src/iker/common/utils/sequtils.py
 src/iker/common/utils/shutils.py
 src/iker/common/utils/span.py
 src/iker/common/utils/strutils.py
@@ -53,12 +53,12 @@ test/iker_tests/common/utils/csv_test.py
 test/iker_tests/common/utils/dbutils_test.py
 test/iker_tests/common/utils/dtutils_test.py
 test/iker_tests/common/utils/funcutils_test.py
+test/iker_tests/common/utils/iterutils_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
 test/iker_tests/common/utils/retry_test.py
-test/iker_tests/common/utils/sequtils_test.py
 test/iker_tests/common/utils/shutils_test.py
 test/iker_tests/common/utils/span_test.py
 test/iker_tests/common/utils/strutils_test.py

{iker_python_common-1.0.63 → iker_python_common-1.0.64}/test/iker_tests/common/utils/argutils_test.py

@@ -6,7 +6,7 @@ import ddt
 
 from iker.common.utils.argutils import ParserTree
 from iker.common.utils.argutils import argparse_spec, make_argparse
-from iker.common.utils.sequtils import seq
+from iker.common.utils.iterutils import seq
 
 
 def dummy_parser_tree():

iker_python_common-1.0.63/test/iker_tests/common/utils/sequtils_test.py → iker_python_common-1.0.64/test/iker_tests/common/utils/iterutils_test.py

@@ -5,12 +5,16 @@ from typing import Self
 
 import ddt
 
-from iker.common.utils.sequtils import Seq
-from iker.common.utils.sequtils import batched, deduped, flatten, grouped
-from iker.common.utils.sequtils import chunk, chunk_between, chunk_with_key, merge_chunks
-from iker.common.utils.sequtils import head, last
-from iker.common.utils.sequtils import init, init_iter, tail, tail_iter
-from iker.common.utils.sequtils import seq
+from iker.common.utils.iterutils import Seq
+from iker.common.utils.iterutils import batched, deduped, flatten, grouped
+from iker.common.utils.iterutils import chunk, chunk_between, chunk_with_key, merge_chunks
+from iker.common.utils.iterutils import dicttree
+from iker.common.utils.iterutils import dicttree_add, dicttree_purge, dicttree_remove
+from iker.common.utils.iterutils import dicttree_children, dicttree_lineage
+from iker.common.utils.iterutils import dicttree_subtree, dicttree_value
+from iker.common.utils.iterutils import head, last
+from iker.common.utils.iterutils import init, init_iter, tail, tail_iter
+from iker.common.utils.iterutils import seq
 
 
 @ddt.ddt
@@ -937,6 +941,692 @@ class SeqUtilsTest(unittest.TestCase):
         self.assertEqual(expect, list(merge_chunks(data, merge_func=merge_func, drop_exclusive_end=True)))
 
 
+@ddt.ddt
+class DicttreeTest(unittest.TestCase):
+    data_dicttree_value = [
+        ({}, [[]], [None]),
+        (
+            {
+                "a": (1, {}),
+                "b": (2, {"c": (3, {}), "d": (4, {"e": (5, {}), "f": (6, {})})}),
+                "g": (7, {"h": (8, {}), "i": (9, {})}),
+            },
+            [
+                ["a"],
+                ["b"],
+                ["b", "c"],
+                ["b", "d"],
+                ["b", "d", "e"],
+                ["b", "d", "f"],
+                ["g"],
+                ["g", "h"],
+                ["g", "i"],
+            ],
+            [1, 2, 3, 4, 5, 6, 7, 8, 9],
+        ),
+        (
+            {
+                "a": (1, {}),
+                "b": (2, {"c": (3, {}), "d": (4, {"e": (5, {}), "f": (6, {})})}),
+                "g": (7, {"h": (8, {}), "i": (9, {})}),
+            },
+            [
+                ["b", "c", "d"],
+                ["b", "c", "d", "e"],
+                ["b", "c", "d", "e", "f"],
+                ["c"],
+                ["d"],
+                ["e"],
+                ["f"],
+                ["g", "h", "i"],
+                ["h"],
+                ["i"],
+            ],
+            [None, None, None, None, None, None, None, None, None, None],
+        ),
+        (
+            {
+                "a": (1, {}),
+                "b": (2, {"c": (None, {}), "d": (4, {"e": (None, {}), "f": (6, {})})}),
+                "g": (None, {"h": (8, {}), "i": (None, {})}),
+            },
+            [
+                ["a"],
+                ["b"],
+                ["b", "c"],
+                ["b", "d"],
+                ["b", "d", "e"],
+                ["b", "d", "f"],
+                ["g"],
+                ["g", "h"],
+                ["g", "i"],
+            ],
+            [1, 2, None, 4, None, 6, None, 8, None],
+        ),
+        (
+            {
+                "a": (1, {}),
+                "b": (2, {"c": (3, {}), "d": (4, {"e": (5, {}), "f": (6, {})})}),
+                "g": (7, {"h": (8, {}), "i": (9, {})}),
+            },
+            [
+                ["b", "c", "d"],
+                ["b", "c", "d", "e"],
+                ["b", "c", "d", "e", "f"],
+                ["c"],
+                ["d"],
+                ["e"],
+                ["f"],
+                ["g", "h", "i"],
+                ["h"],
+                ["i"],
+            ],
+            [None, None, None, None, None, None, None, None, None, None],
+        ),
+    ]
+
+    @ddt.idata(data_dicttree_value)
+    @ddt.unpack
+    def test_dicttree_value(self, tree: dicttree[str, int], paths, expects):
+        for expect, path in zip(expects, paths):
+            self.assertEqual(expect, dicttree_value(tree, path))
+
+    data_dicttree_subtree = [
+        ({}, [[]], [{}]),
+        (
+            {
+                "a": (1, {}),
+                "b": (2, {"c": (3, {}), "d": (4, {"e": (5, {}), "f": (6, {})})}),
+                "g": (7, {"h": (8, {}), "i": (9, {})}),
+            },
+            [
+                [],
+                ["a"],
+                ["b"],
+                ["b", "c"],
+                ["b", "d"],
+                ["b", "d", "e"],
+                ["b", "d", "f"],
+                ["g"],
+                ["g", "h"],
+                ["g", "i"],
+            ],
+            [
+                {
+                    "a": (1, {}),
+                    "b": (2, {"c": (3, {}), "d": (4, {"e": (5, {}), "f": (6, {})})}),
+                    "g": (7, {"h": (8, {}), "i": (9, {})}),
+                },
+                {},
+                {"c": (3, {}), "d": (4, {"e": (5, {}), "f": (6, {})})},
+                {},
+                {"e": (5, {}), "f": (6, {})},
+                {},
+                {},
+                {"h": (8, {}), "i": (9, {})},
+                {},
+                {},
+            ],
+        ),
+        (
+            {
+                "a": (1, {}),
+                "b": (2, {"c": (3, {}), "d": (4, {"e": (5, {}), "f": (6, {})})}),
+                "g": (7, {"h": (8, {}), "i": (9, {})}),
+            },
+            [
+                ["b", "c", "d"],
+                ["b", "c", "d", "e"],
+                ["b", "c", "d", "e", "f"],
+                ["c"],
+                ["d"],
+                ["e"],
+                ["f"],
+                ["g", "h", "i"],
+                ["h"],
+                ["i"],
+            ],
+            [None, None, None, None, None, None, None, None, None, None],
+        ),
+        (
+            {
+                "a": (1, {}),
+                "b": (2, {"c": (None, {}), "d": (4, {"e": (None, {}), "f": (6, {})})}),
+                "g": (None, {"h": (8, {}), "i": (None, {})}),
+            },
+            [
+                [],
+                ["a"],
+                ["b"],
+                ["b", "c"],
+                ["b", "d"],
+                ["b", "d", "e"],
+                ["b", "d", "f"],
+                ["g"],
+                ["g", "h"],
+                ["g", "i"],
+            ],
+            [
+                {
+                    "a": (1, {}),
+                    "b": (2, {"c": (None, {}), "d": (4, {"e": (None, {}), "f": (6, {})})}),
+                    "g": (None, {"h": (8, {}), "i": (None, {})}),
+                },
+                {},
+                {"c": (None, {}), "d": (4, {"e": (None, {}), "f": (6, {})})},
+                {},
+                {"e": (None, {}), "f": (6, {})},
+                {},
+                {},
+                {"h": (8, {}), "i": (None, {})},
+                {},
+                {},
+            ],
+        ),
+        (
+            {
+                "a": (1, {}),
+                "b": (2, {"c": (None, {}), "d": (4, {"e": (None, {}), "f": (6, {})})}),
+                "g": (None, {"h": (8, {}), "i": (None, {})}),
+            },
+            [
+                ["b", "c", "d"],
+                ["b", "c", "d", "e"],
+                ["b", "c", "d", "e", "f"],
+                ["c"],
+                ["d"],
+                ["e"],
+                ["f"],
+                ["g", "h", "i"],
+                ["h"],
+                ["i"],
+            ],
+            [None, None, None, None, None, None, None, None, None, None],
+        ),
+    ]
+
+    @ddt.idata(data_dicttree_subtree)
+    @ddt.unpack
+    def test_dicttree_subtree(self, tree: dicttree[str, int], paths, expects):
+        for expect, path in zip(expects, paths):
+            self.assertEqual(expect, dicttree_subtree(tree, path))
+
+    data_dicttree_children = [
+        ({}, [[]], False, [set()]),
+        (
+            {
+                "a": (1, {}),
+                "b": (2, {"c": (3, {}), "d": (4, {"e": (5, {}), "f": (6, {})})}),
+                "g": (7, {"h": (8, {}), "i": (9, {})}),
+            },
+            [
+                [],
+                ["a"],
+                ["b"],
+                ["b", "c"],
+                ["b", "d"],
+                ["b", "d", "e"],
+                ["b", "d", "f"],
+                ["g"],
+                ["g", "h"],
+                ["g", "i"],
+            ],
+            False,
+            [{1, 2, 3, 4, 5, 6, 7, 8, 9}, set(), {3, 4, 5, 6}, set(), {5, 6}, set(), set(), {8, 9}, set(), set()],
+        ),
+        (
+            {
+                "a": (1, {}),
+                "b": (2, {"c": (3, {}), "d": (4, {"e": (5, {}), "f": (6, {})})}),
+                "g": (7, {"h": (8, {}), "i": (9, {})}),
+            },
+            [
+                ["b", "c", "d"],
+                ["b", "c", "d", "e"],
+                ["b", "c", "d", "e", "f"],
+                ["c"],
+                ["d"],
+                ["e"],
+                ["f"],
+                ["g", "h", "i"],
+                ["h"],
+                ["i"],
+            ],
+            False,
+            [set(), set(), set(), set(), set(), set(), set(), set(), set(), set()],
+        ),
+        (
+            {
+                "a": (1, {}),
+                "b": (2, {"c": (None, {}), "d": (4, {"e": (None, {}), "f": (6, {})})}),
+                "g": (None, {"h": (8, {}), "i": (None, {})}),
+            },
+            [
+                [],
+                ["a"],
+                ["b"],
+                ["b", "c"],
+                ["b", "d"],
+                ["b", "d", "e"],
+                ["b", "d", "f"],
+                ["g"],
+                ["g", "h"],
+                ["g", "i"],
+            ],
+            False,
+            [{1, 2, 4, 6, 8}, set(), {4, 6}, set(), {6}, set(), set(), {8}, set(), set()],
+        ),
+        (
+            {
+                "a": (1, {}),
+                "b": (2, {"c": (None, {}), "d": (4, {"e": (None, {}), "f": (6, {})})}),
+                "g": (None, {"h": (8, {}), "i": (None, {})}),
+            },
+            [
+                ["b", "c", "d"],
+                ["b", "c", "d", "e"],
+                ["b", "c", "d", "e", "f"],
+                ["c"],
+                ["d"],
+                ["e"],
+                ["f"],
+                ["g", "h", "i"],
+                ["h"],
+                ["i"],
+            ],
+            False,
+            [set(), set(), set(), set(), set(), set(), set(), set(), set(), set()],
+        ),
+        (
+            {
+                "a": (1, {}),
+                "b": (2, {"c": (3, {}), "d": (4, {"e": (5, {}), "f": (6, {})})}),
+                "g": (7, {"h": (8, {}), "i": (9, {})}),
+            },
+            [
+                [],
+                ["a"],
+                ["b"],
+                ["b", "c"],
+                ["b", "d"],
+                ["b", "d", "e"],
+                ["b", "d", "f"],
+                ["g"],
+                ["g", "h"],
+                ["g", "i"],
+            ],
+            True,
+            [{1, 3, 5, 6, 8, 9}, set(), {3, 5, 6}, set(), {5, 6}, set(), set(), {8, 9}, set(), set()],
+        ),
+        (
+            {
+                "a": (1, {}),
+                "b": (2, {"c": (3, {}), "d": (4, {"e": (5, {}), "f": (6, {})})}),
+                "g": (7, {"h": (8, {}), "i": (9, {})}),
+            },
+            [
+                ["b", "c", "d"],
+                ["b", "c", "d", "e"],
+                ["b", "c", "d", "e", "f"],
+                ["c"],
+                ["d"],
+                ["e"],
+                ["f"],
+                ["g", "h", "i"],
+                ["h"],
+                ["i"],
+            ],
+            True,
+            [set(), set(), set(), set(), set(), set(), set(), set(), set(), set()],
+        ),
+        (
+            {
+                "a": (1, {}),
+                "b": (2, {"c": (None, {}), "d": (4, {"e": (None, {}), "f": (6, {})})}),
+                "g": (None, {"h": (8, {}), "i": (None, {})}),
+            },
+            [
+                [],
+                ["a"],
+                ["b"],
+                ["b", "c"],
+                ["b", "d"],
+                ["b", "d", "e"],
+                ["b", "d", "f"],
+                ["g"],
+                ["g", "h"],
+                ["g", "i"],
+            ],
+            True,
+            [{1, 6, 8}, set(), {6}, set(), {6}, set(), set(), {8}, set(), set()],
+        ),
+        (
+            {
+                "a": (1, {}),
+                "b": (2, {"c": (None, {}), "d": (4, {"e": (None, {}), "f": (6, {})})}),
+                "g": (None, {"h": (8, {}), "i": (None, {})}),
+            },
+            [
+                ["b", "c", "d"],
+                ["b", "c", "d", "e"],
+                ["b", "c", "d", "e", "f"],
+                ["c"],
+                ["d"],
+                ["e"],
+                ["f"],
+                ["g", "h", "i"],
+                ["h"],
+                ["i"],
+            ],
+            True,
+            [set(), set(), set(), set(), set(), set(), set(), set(), set(), set()],
+        ),
+    ]
+
+    @ddt.idata(data_dicttree_children)
+    @ddt.unpack
+    def test_dicttree_children(self, tree: dicttree[str, int], paths, leaves_only, expects):
+        for expect, path in zip(expects, paths):
+            subtree = dicttree_subtree(tree, path)
+            if subtree is None:
+                self.assertEqual(expect, set())
+            else:
+                self.assertEqual(expect, set(dicttree_children(subtree, leaves_only=leaves_only)))
+
+    data_dicttree_lineage = [
+        ({}, [[]], [[]]),
+        (
+            {
+                "a": (1, {}),
+                "b": (2, {"c": (3, {}), "d": (4, {"e": (5, {}), "f": (6, {})})}),
+                "g": (7, {"h": (8, {}), "i": (9, {})}),
+            },
+            [
+                [],
+                ["a"],
+                ["b"],
+                ["b", "c"],
+                ["b", "d"],
+                ["b", "d", "e"],
+                ["b", "d", "f"],
+                ["g"],
+                ["g", "h"],
+                ["g", "i"],
+            ],
+            [[], [1], [2], [2, 3], [2, 4], [2, 4, 5], [2, 4, 6], [7], [7, 8], [7, 9]],
+        ),
+        (
+            {
+                "a": (1, {}),
+                "b": (2, {"c": (3, {}), "d": (4, {"e": (5, {}), "f": (6, {})})}),
+                "g": (7, {"h": (8, {}), "i": (9, {})}),
+            },
+            [
+                ["b", "c", "d"],
+                ["b", "c", "d", "e"],
+                ["b", "c", "d", "e", "f"],
+                ["c"],
+                ["d"],
+                ["e"],
+                ["f"],
+                ["g", "h", "i"],
+                ["h"],
+                ["i"],
+            ],
+            [[2, 3], [2, 3], [2, 3], [], [], [], [], [7, 8], [], []],
+        ),
+        (
+            {
+                "a": (1, {}),
+                "b": (2, {"c": (None, {}), "d": (4, {"e": (None, {}), "f": (6, {})})}),
+                "g": (None, {"h": (8, {}), "i": (None, {})}),
+            },
+            [
+                [],
+                ["a"],
+                ["b"],
+                ["b", "c"],
+                ["b", "d"],
+                ["b", "d", "e"],
+                ["b", "d", "f"],
+                ["g"],
+                ["g", "h"],
+                ["g", "i"],
+            ],
+            [[], [1], [2], [2], [2, 4], [2, 4], [2, 4, 6], [], [8], []],
+        ),
+        (
+            {
+                "a": (1, {}),
+                "b": (2, {"c": (None, {}), "d": (4, {"e": (None, {}), "f": (6, {})})}),
+                "g": (None, {"h": (8, {}), "i": (None, {})}),
+            },
+            [
+                ["b", "c", "d"],
+                ["b", "c", "d", "e"],
+                ["b", "c", "d", "e", "f"],
+                ["c"],
+                ["d"],
+                ["e"],
+                ["f"],
+                ["g", "h", "i"],
+                ["h"],
+                ["i"],
+            ],
+            [[2], [2], [2], [], [], [], [], [8], [], []],
+        ),
+    ]
+
+    @ddt.idata(data_dicttree_lineage)
+    @ddt.unpack
+    def test_dicttree_lineage(self, tree: dicttree[str, int], paths, expects):
+        for expect, path in zip(expects, paths):
+            self.assertEqual(expect, list(dicttree_lineage(tree, path)))
+
+    data_dicttree_purge = [
+        ({}, {}),
+        ({"a": (1, {})}, {"a": (1, {})}),
+        ({"a": (None, {})}, {}),
+        (
+            {
+                "a": (1, {}),
+                "b": (2, {"c": (3, {}), "d": (4, {"e": (5, {}), "f": (6, {})})}),
+                "g": (7, {"h": (8, {}), "i": (9, {})}),
+            },
+            {
+                "a": (1, {}),
+                "b": (2, {"c": (3, {}), "d": (4, {"e": (5, {}), "f": (6, {})})}),
+                "g": (7, {"h": (8, {}), "i": (9, {})}),
+            },
+        ),
+        (
+            {
+                "a": (1, {}),
+                "b": (2, {"c": (None, {}), "d": (4, {"e": (None, {}), "f": (6, {})})}),
+                "g": (None, {"h": (8, {}), "i": (None, {})}),
+            },
+            {
+                "a": (1, {}),
+                "b": (2, {"d": (4, {"f": (6, {})})}),
+                "g": (None, {"h": (8, {})}),
+            },
+        ),
+    ]
+
+    @ddt.idata(data_dicttree_purge)
+    @ddt.unpack
+    def test_dicttree_purge(self, tree: dicttree[str, int], expect):
+        self.assertEqual(expect, dicttree_purge(tree))
+
+    data_dicttree_add = [
+        ({}, ["a"], 1, True, False, {"a": (1, {})}),
+        ({"a": (1, {})}, ["b"], 2, True, False, {"a": (1, {}), "b": (2, {})}),
+        ({"a": (1, {})}, ["a"], 2, True, True, {"a": (2, {})}),
+        (
+            {
+                "a": (1, {}),
+                "b": (2, {"c": (3, {})}),
+                "d": (None, {"e": (5, {})}),
+            },
+            ["b", "d", "e"],
+            5,
+            True,
+            False,
+            {
+                "a": (1, {}),
+                "b": (2, {"c": (3, {}), "d": (None, {"e": (5, {})})}),
+                "d": (None, {"e": (5, {})}),
+            },
+        ),
+        (
+            {
+                "a": (1, {}),
+                "b": (2, {"c": (3, {})}),
+                "d": (None, {"e": (5, {})}),
+            },
+            ["d"],
+            4,
+            True,
+            False,
+            {
+                "a": (1, {}),
+                "b": (2, {"c": (3, {})}),
+                "d": (4, {"e": (5, {})}),
+            },
+        ),
+        (
+            {
+                "a": (1, {}),
+                "b": (2, {"c": (3, {})}),
+                "d": (None, {"e": (5, {})}),
+            },
+            ["b"],
+            22,
+            True,
+            True,
+            {
+                "a": (1, {}),
+                "b": (22, {"c": (3, {})}),
+                "d": (None, {"e": (5, {})}),
+            },
+        ),
+        (
+            {
+                "a": (1, {}),
+                "b": (2, {"c": (3, {})}),
+                "d": (None, {"e": (5, {})}),
+            },
+            ["d", "e"],
+            55,
+            True,
+            True,
+            {
+                "a": (1, {}),
+                "b": (2, {"c": (3, {})}),
+                "d": (None, {"e": (55, {})}),
+            },
+        ),
+    ]
+
+    @ddt.idata(data_dicttree_add)
+    @ddt.unpack
+    def test_dicttree_add(self, tree: dicttree[str, int], path, value, create_prefix, overwrite, expect):
+        self.assertEqual(expect, dicttree_add(tree, path, value, create_prefix=create_prefix, overwrite=overwrite))
+
+    data_dicttree_add__bad_cases = [
+        ({}, [], 0, True, False),
+        ({"a": (1, {})}, ["a"], 2, True, False),
+        (
+            {
+                "a": (1, {}),
+                "b": (2, {"c": (3, {})}),
+                "d": (None, {"e": (5, {})}),
+            },
+            ["b", "d", "e"],
+            5,
+            False,
+            False,
+        ),
+    ]
+
+    @ddt.idata(data_dicttree_add__bad_cases)
+    @ddt.unpack
+    def test_dicttree_add__bad_cases(self, tree: dicttree[str, int], path, value, create_prefix, overwrite):
+        with self.assertRaises(ValueError):
+            dicttree_add(tree, path, value, create_prefix=create_prefix, overwrite=overwrite)
+
+    data_dicttree_remove = [
+        ({"a": (1, {})}, ["a"], False, {"a": (None, {})}),
+        (
+            {
+                "a": (1, {}),
+                "b": (2, {"c": (3, {})}),
+                "d": (None, {"e": (5, {})}),
+            },
+            ["b"],
+            False,
+            {
+                "a": (1, {}),
+                "b": (None, {"c": (3, {})}),
+                "d": (None, {"e": (5, {})}),
+            },
+        ),
+        (
+            {
+                "a": (1, {}),
+                "b": (2, {"c": (3, {})}),
+                "d": (None, {"e": (5, {})}),
+            },
+            ["b"],
+            True,
+            {
+                "a": (1, {}),
+                "b": (None, {}),
+                "d": (None, {"e": (5, {})}),
+            },
+        ),
+        (
+            {
+                "a": (1, {}),
+                "b": (2, {"c": (3, {})}),
+                "d": (None, {"e": (5, {})}),
+            },
+            ["b", "c"],
+            False,
+            {
+                "a": (1, {}),
+                "b": (2, {"c": (None, {})}),
+                "d": (None, {"e": (5, {})}),
+            },
+        ),
+    ]
+
+    @ddt.idata(data_dicttree_remove)
+    @ddt.unpack
+    def test_dicttree_remove(self, tree: dicttree[str, int], path, recursive, expect):
+        self.assertEqual(expect, dicttree_remove(tree, path, recursive=recursive))
+
+    data_dicttree_remove__bad_cases = [
+        ({}, [], False),
+        ({"a": (1, {})}, ["b"], False),
+        (
+            {
+                "a": (1, {}),
+                "b": (2, {"c": (3, {})}),
+                "d": (None, {"e": (5, {})}),
+            },
+            ["e", "f"],
+            False,
+        ),
+    ]
+
+    @ddt.idata(data_dicttree_remove__bad_cases)
+    @ddt.unpack
+    def test_dicttree_remove__bad_cases(self, tree: dicttree[str, int], path, recursive):
+        with self.assertRaises(ValueError):
+            dicttree_remove(tree, path, recursive=recursive)
+
+
 @dataclasses.dataclass(frozen=True, eq=True, order=True)
 class Naming(object):
     serial: int

{iker_python_common-1.0.63 → iker_python_common-1.0.64}/test/iker_tests/common/utils/span_test.py

@@ -3,7 +3,7 @@ import unittest
 
 import ddt
 
-from iker.common.utils.sequtils import last
+from iker.common.utils.iterutils import last
 from iker.common.utils.span import SpanRelation
 from iker.common.utils.span import span_relation, spans_intersect, spans_subtract, spans_union