nested-mapping 0.12.0__tar.gz → 0.13.0__tar.gz

{nested_mapping-0.12.0 → nested_mapping-0.13.0}/CHANGELOG.md

@@ -5,6 +5,15 @@ All notable changes to this project will be documented in this file.
 The format is based on [Keep a Changelog](http://keepachangelog.com/)
 and this project adheres to [Semantic Versioning](http://semver.org/).
 
+## [0.13.0] - 2026-11-03
+
+- feature: enable `remap_keys` and `make_reorder_fcn` to insert extra levels of nesting. 
+  Should be enabled explicitly via `allow_insert_items`.
+
+## [0.12.1] - 2026-10-29
+
+- feature: extra protection for `match_keys` to avoid keys being skipped. Can be disabled.
+
 ## [0.12.0] - 2026-10-01
 
 - add `skip_fcn` argument for `walk*` methods to skip items from iteration.

{nested_mapping-0.12.0/src/nested_mapping.egg-info → nested_mapping-0.13.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: nested-mapping
-Version: 0.12.0
+Version: 0.13.0
 Summary: A wrapper and a toolkit for working with nested mappings in Python
 Author-email: DAGModelling Team <dagflow@jinr.ru>
 Maintainer-email: DAGModelling Team <dagflow@jinr.ru>

{nested_mapping-0.12.0 → nested_mapping-0.13.0}/src/nested_mapping/__version__.py

@@ -18,7 +18,7 @@ version_tuple: tuple[int | str, ...]
 commit_id: str | None
 __commit_id__: str | None
 
-__version__ = version = '0.12.0'
-__version_tuple__ = version_tuple = (0, 12, 0)
+__version__ = version = '0.13.0'
+__version_tuple__ = version_tuple = (0, 13, 0)
 
-__commit_id__ = commit_id = 'gd3a44dafb'
+__commit_id__ = commit_id = 'g4a18ec946'

{nested_mapping-0.12.0 → nested_mapping-0.13.0}/src/nested_mapping/tools/map.py

@@ -52,11 +52,12 @@ def remap_items(
         | tuple[tuple[str, ...], tuple[str, ...]]
         | list[int]
         | list[list[str]]
-        | Mapping[str, list[str] | tuple[str]]
+        | Mapping[str, list[str] | tuple[str, ...]]
         | None
     ) = None,
     skip_indices_source: Sequence[KeyLike | set] | None = None,
     skip_indices_target: Sequence[KeyLike | set] | None = None,
+    allow_insert_items: bool = False,
     fcn: Callable[[Any], Any] | None = None,
     verbose: bool = False,
 ) -> NestedMapping:
@@ -67,7 +68,7 @@ def remap_items(
 
     skip_source = _make_skip_fcn(skip_indices_source)
     skip_target = _make_skip_fcn(skip_indices_target)
-    reorder = make_reorder_function(reorder_indices)
+    reorder = make_reorder_function(reorder_indices, allow_insert_items=allow_insert_items)
 
     if fcn is None:
         fcn = lambda o: o
@@ -79,15 +80,11 @@ def remap_items(
         for key, value in source.walkitems():
             if skip_source(key):
                 continue
-            for newkey in product(
-                *tuple(rename_indices.get(skey, (skey,)) for skey in key)
-            ):
+            for newkey in product(*tuple(rename_indices.get(skey, (skey,)) for skey in key)):
                 newkey_ordered = reorder(newkey)
                 if skip_target(newkey_ordered):
                     if verbose:
-                        print(
-                            f"remap: skip {'.'.join(key)} → {'.'.join(newkey_ordered)}"
-                        )
+                        print(f"remap: skip {'.'.join(key)} → {'.'.join(newkey_ordered)}")
                     continue
                 if verbose:
                     print(
@@ -96,6 +93,9 @@ def remap_items(
                 target[newkey_ordered] = fcn(value)
     else:
         for key, value in source.walkitems():
+            if skip_source(key):
+                print(f"remap: skip {'.'.join(key)}")
+                continue
             newkey_ordered = reorder(key)
             if skip_target(newkey_ordered):
                 if verbose:
@@ -128,39 +128,73 @@ def make_reorder_function(
         | tuple[tuple[str, ...], tuple[str, ...]]
         | Sequence[int]
         | Sequence[Sequence[str]]
-        | Mapping[str, list[str] | tuple[str]]
+        | Mapping[str, list[str] | tuple[str, ...]]
         | None
     ),
     *,
     allow_skip_items: bool = False,
+    allow_insert_items: bool = False,
 ) -> Callable:
+    order_from_extended: list[None | str] = []
     match reorder_indices:
         case [int(), *_]:
-            index_order = reorder_indices
+            index_order = list(reorder_indices)
             len_from = len(index_order)
+
+            match_length_from = not allow_skip_items
+
+            if allow_insert_items:
+                raise ValueError(
+                    "make_reorder_function: inserting items is forbidden with tuple[int] arguments"
+                )
         case [[str(), *_] as order_from, [str(), *_] as order_to] | {
             "from": [str(), *_] as order_from,
             "to": [str(), *_] as order_to,
         }:
+            match_length_from = True
+
             len_from = len(order_from)
-            try:
-                index_order = tuple(order_from.index(item) for item in order_to)
-            except ValueError:
-                raise ValueError(
-                    f"Inconsistent order definitions {order_from} and {order_to}"
-                )
+            if allow_insert_items:
+                order_from_extended: list[None | str] = [None] * len(order_from)
+                index_order: list[None | int] = [None] * len(order_to)
+                not_processed_indices = set(range(len(order_from)))
+                for i, name in enumerate(order_to):
+                    try:
+                        index = order_from.index(name)
+                        not_processed_indices.remove(index)
+                    except ValueError:
+                        index = len(order_from_extended)
+                        order_from_extended.append(name)
+                    index_order[i] = index
+
+                if not_processed_indices and not allow_skip_items:
+                    raise ValueError(
+                        f"Inconsistent order definitions (can not skip) {order_from}→{order_to}"
+                    )
+            else:
+                try:
+                    index_order = list(order_from.index(item) for item in order_to)
+                except ValueError:
+                    raise ValueError(
+                        f"Inconsistent order definitions (can neigher skip no insert) {order_from}→{order_to}"
+                    )
+
         case None:
             len_from = None
+            match_length_from = False
             allow_skip_items = True
             return lambda key: key
         case _:
             raise ValueError(f"Invalid order specification: {reorder_indices}")
 
     def reorder_indices_fcn(key: Sequence):
-        if not allow_skip_items and len(key) != len_from:
-            raise ValueError(
-                f"inconsistent index length: {len(index_order)} vs required {len(key)}"
+        if match_length_from and len(key) != len_from:
+            raise ValueError(f"inconsistent key length: {len(key)} vs required {len_from}")
+        if allow_insert_items:
+            return key.__class__(
+                key[idx] if idx < len(key) else order_from_extended[idx] for idx in index_order
             )
-        return key.__class__(key[idx] for idx in index_order)
+        else:
+            return key.__class__(key[idx] for idx in index_order)
 
     return reorder_indices_fcn

nested_mapping-0.13.0/src/nested_mapping/tools/match.py

@@ -0,0 +1,282 @@
+from __future__ import annotations
+
+from contextlib import suppress
+from typing import Any, TYPE_CHECKING, TypeVar
+
+from ordered_set import OrderedSet
+
+from ..typing import Key, KeyLike, TupleKey, properkey, setkey
+
+if TYPE_CHECKING:
+    from collections.abc import Callable, Iterable, Sequence
+
+SetType = TypeVar("SetType", set[str], OrderedSet[str])
+
+
+def set_keys_consistent_ordered(
+    set_key_left: OrderedSet[str], set_key_right: OrderedSet[str]
+) -> bool:
+    return set_key_left == set_key_right
+
+
+def set_keys_consistent_unordered(set_key_left: SetType, set_key_right: SetType) -> bool:
+    return not set_key_left.symmetric_difference(set_key_right)
+
+
+def set_keys_consistent_symmetric(set_key_left: SetType, set_key_right: SetType) -> bool:
+    return set_key_left.issubset(set_key_right) or set_key_right.issubset(set_key_left)
+
+
+def set_keys_consistent_left_in_right(set_key_left: SetType, set_key_right: SetType) -> bool:
+    return set_key_left.issubset(set_key_right)
+
+
+def set_keys_consistent_right_in_left(set_key_left: SetType, set_key_right: SetType) -> bool:
+    return set_key_right.issubset(set_key_left)
+
+
+def match_keys_to_key(
+    keys_left: Sequence[KeyLike],
+    key_right_tuple: TupleKey,
+    key_right_set: SetType,
+    keys_consistent_fcn: Callable[[SetType, SetType], bool],
+    fcn: Callable[[TupleKey, TupleKey], Any],
+    *,
+    fcn_on_reject: Callable[[TupleKey, TupleKey], Any] | None = None,
+    collect_skipped_right_keys: bool = False,
+    collect_skipped_left_keys: bool = False,
+    skipped_left_keys: set | None = None,
+    processed_left_keys: set | None = None,
+    processed_right_keys: set | None = None,
+    skipped_right_keys: set | None = None,
+    require_no_duplicate_right_matches: bool = False,
+) -> bool:
+    assert not collect_skipped_right_keys or (
+        processed_right_keys is not None and skipped_right_keys is not None
+    )
+    assert not collect_skipped_left_keys or (
+        processed_left_keys is not None and skipped_left_keys is not None
+    )
+    right_key_processed = False
+    key_left_match = None
+    for key_left in keys_left:
+        key_left_tuple = properkey(key_left)
+        key_left_set = OrderedSet(key_left_tuple)
+
+        if not keys_consistent_fcn(key_left_set, key_right_set):  # pyright: ignore [reportArgumentType]
+            if (
+                collect_skipped_left_keys
+                and key_left_tuple
+                not in processed_left_keys  # pyright: ignore [reportOperatorIssue]
+            ):
+                skipped_left_keys.add(  # pyright: ignore [reportOptionalMemberAccess]
+                    key_left_tuple
+                )
+            if (
+                collect_skipped_right_keys
+                and key_right_tuple
+                not in processed_right_keys  # pyright: ignore [reportOperatorIssue]
+            ):
+                skipped_right_keys.add(  # pyright: ignore [reportOptionalMemberAccess]
+                    key_right_tuple
+                )
+            if fcn_on_reject:
+                fcn_on_reject(key_left_tuple, key_right_tuple)
+            continue
+
+        fcn(key_left_tuple, key_right_tuple)
+        if require_no_duplicate_right_matches and right_key_processed:
+            raise ValueError(
+                f"match_keys: right key {key_right_tuple!s} was matched more than once to "
+                f"{key_left_match!s}; {key_left_tuple!s}..."
+            )
+
+        right_key_processed = True
+        key_left_match = key_left_tuple
+
+        if collect_skipped_left_keys:
+            with suppress(KeyError):
+                skipped_left_keys.remove(
+                    key_left_tuple
+                )  # pyright: ignore [reportOptionalMemberAccess]
+            processed_left_keys.add(key_left_tuple)  # pyright: ignore [reportOptionalMemberAccess]
+
+        if collect_skipped_right_keys:
+            with suppress(KeyError):
+                skipped_right_keys.remove(
+                    key_right_tuple
+                )  # pyright: ignore [reportOptionalMemberAccess]
+            processed_right_keys.add(
+                key_right_tuple
+            )  # pyright: ignore [reportOptionalMemberAccess]
+
+    return right_key_processed
+
+
+def zip_match_keys_to_key(
+    keys_left: Sequence[KeyLike],
+    key_right_tuple: TupleKey,
+    key_right_set: SetType,
+    keys_consistent_fcn: Callable[[SetType, SetType], bool],
+):
+    for key_left in keys_left:
+        key_left_tuple = properkey(key_left)
+        key_left_set = OrderedSet(key_left_tuple)
+        if keys_consistent_fcn(key_left_set, key_right_set):  # pyright: ignore [reportArgumentType]
+            yield key_left_tuple, key_right_tuple
+
+
+def zip_match_keys_to_keys(
+    keys_left: Sequence[KeyLike],
+    keys_right: Sequence[KeyLike],
+    keys_consistent_fcn: Callable[[SetType, SetType], bool],
+):
+    for key_right in keys_right:
+        key_right_tuple = properkey(key_right)
+        key_right_set = OrderedSet(key_right_tuple)
+
+        yield from zip_match_keys_to_key(
+            keys_left, key_right_tuple, key_right_set, keys_consistent_fcn  # pyright: ignore [reportArgumentType]
+        )
+
+
+def match_keys(
+    keys_left_seq: Sequence[Sequence[KeyLike]],
+    keys_right: Iterable[KeyLike],
+    fcn: Callable[[int, TupleKey, TupleKey], Any],
+    *,
+    fcn_outer_before: Callable[[TupleKey], Any] | None = None,
+    fcn_outer_after: Callable[[TupleKey], Any] | None = None,
+    fcn_on_reject: Callable[[int, TupleKey, TupleKey], Any] | None = None,
+    left_in_right: bool = True,
+    right_in_left: bool = True,
+    require_all_right_keys_processed: bool = True,
+    require_all_left_keys_processed: bool = True,
+    require_all_left_keys_match_right: bool = True,
+    require_no_duplicate_right_matches: bool = False,
+    unmatched_right_keys_should_contain: Sequence[KeyLike] | None = None,
+    skippable_left_keys_should_contain: Sequence[KeyLike] | None = None,
+) -> None:
+    if isinstance(keys_right, str):
+        raise RuntimeError("`keys_right` should be iterable, but not string")
+    if not keys_left_seq:
+        raise RuntimeError("Left sequence is empty")
+
+    if left_in_right and right_in_left:
+        keys_consistent_fcn = set_keys_consistent_symmetric
+    elif left_in_right:
+        keys_consistent_fcn = set_keys_consistent_left_in_right
+    elif right_in_left:
+        keys_consistent_fcn = set_keys_consistent_right_in_left
+    else:
+        raise RuntimeError(
+            "At least on of the flags should be true: right_in_left or left_in_right"
+        )
+
+    skipped_right_keys = []
+    processed_right_keys = set()
+    processed_left_keys = set()
+    skipped_left_keys = set()
+    skipped_right_keys_for_left = []
+    processed_right_keys_for_left = []
+
+    collect_skipped_left_keys = bool(
+        require_all_left_keys_processed or skippable_left_keys_should_contain is not None
+    )
+    collect_skipped_right_keys = bool(
+        require_all_left_keys_match_right or unmatched_right_keys_should_contain is not None
+    )
+
+    i_left = -1
+    for key_right in keys_right:
+        key_right_tuple = properkey(key_right)
+        key_right_set = OrderedSet(key_right_tuple)
+        if fcn_outer_before is not None:
+            fcn_outer_before(key_right_tuple)
+
+        right_key_processed = False
+        for i_left, keys_left in enumerate(keys_left_seq):
+            if i_left >= len(skipped_right_keys_for_left):
+                processed_right_keys_for_left.append(processed_right_keys_i := set())
+                skipped_right_keys_for_left.append(skipped_right_keys_i := set())
+            else:
+                processed_right_keys_i = processed_right_keys_for_left[i_left]
+                skipped_right_keys_i = skipped_right_keys_for_left[i_left]
+
+            right_key_processed = match_keys_to_key(
+                keys_left,
+                key_right_tuple,
+                key_right_set,
+                keys_consistent_fcn,
+                lambda *args: fcn(i_left, *args),
+                fcn_on_reject=(
+                    (lambda *args: fcn_on_reject(i_left, *args))
+                    if fcn_on_reject is not None
+                    else None
+                ),
+                collect_skipped_left_keys=collect_skipped_left_keys,
+                collect_skipped_right_keys=collect_skipped_right_keys,
+                skipped_left_keys=skipped_left_keys,
+                processed_left_keys=processed_left_keys,
+                skipped_right_keys=skipped_right_keys_i,
+                processed_right_keys=processed_right_keys_i,
+                require_no_duplicate_right_matches=require_no_duplicate_right_matches,
+            )
+
+        if fcn_outer_after is not None:
+            fcn_outer_after(key_right_tuple)
+
+        if right_key_processed:
+            if require_all_left_keys_match_right:
+                processed_right_keys.add(key_right_tuple)
+        elif require_all_right_keys_processed:
+            skipped_right_keys.append(key_right_tuple)
+
+    for i, (skipped_left_keys_i, processed_left_keys_i) in enumerate(
+        zip(skipped_right_keys_for_left, processed_right_keys_for_left)
+    ):
+        if processed_left_keys_i != processed_right_keys:
+            if require_all_left_keys_match_right:
+                raise ValueError(
+                    f"match_keys: left sequence {i} did not provide keys {skipped_left_keys_i!s}"
+                )
+            _check_for_unexpectedly_skipped_keys(
+                skipped_left_keys_i,
+                unmatched_right_keys_should_contain,
+                kind=f"missing left ({i})",
+            )
+
+    if skipped_left_keys:
+        if require_all_left_keys_processed:
+            raise ValueError(f"match_keys: there were unprocessed left keys {skipped_left_keys!s}")
+        _check_for_unexpectedly_skipped_keys(
+            skipped_left_keys, unmatched_right_keys_should_contain, kind="skipped left"
+        )
+
+    if require_all_right_keys_processed and skipped_right_keys:
+        raise ValueError(f"match_keys: there were unprocessed right keys {skipped_right_keys!s}")
+
+
+def _check_for_unexpectedly_skipped_keys(
+    skipped_keys: Sequence[Key] | set[Key], should_contain: Sequence[KeyLike] | None, kind: str
+):
+    if unexpectedly_skipped_keys := _get_unexpectedly_skipped_keys(skipped_keys, should_contain):
+        raise ValueError(
+            f"match_keys: there were {kind} keys {skipped_keys!s}. "
+            f"{unexpectedly_skipped_keys} should not have been skipped."
+        )
+
+
+def _get_unexpectedly_skipped_keys(
+    skipped_keys: Sequence[Key] | set[Key], should_contain: Sequence[KeyLike] | None
+) -> Sequence[Key]:
+    if not should_contain:
+        return []
+
+    setkeys = tuple(setkey(keypart) for keypart in should_contain)
+    incorrectly_skipped_keys = []
+    for skipped_key in skipped_keys:
+        if not any(setkey.issubset(skipped_key) for setkey in setkeys):
+            incorrectly_skipped_keys.append(skipped_key)
+
+    return incorrectly_skipped_keys

{nested_mapping-0.12.0 → nested_mapping-0.13.0/src/nested_mapping.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: nested-mapping
-Version: 0.12.0
+Version: 0.13.0
 Summary: A wrapper and a toolkit for working with nested mappings in Python
 Author-email: DAGModelling Team <dagflow@jinr.ru>
 Maintainer-email: DAGModelling Team <dagflow@jinr.ru>

nested_mapping-0.13.0/src/nested_mapping.egg-info/scm_version.json

@@ -0,0 +1,8 @@
+{
+  "tag": "0.13.0",
+  "distance": 0,
+  "node": "g4a18ec94669d327766012fd5493c902427e34392",
+  "dirty": false,
+  "branch": "HEAD",
+  "node_date": "2026-11-03"
+}

{nested_mapping-0.12.0 → nested_mapping-0.13.0}/tests/test_map.py

@@ -17,6 +17,7 @@ def test_remap_items_01():
     d_renamed_reordered_skipped_source_match = NestedMapping()
     d_renamed_reordered_skipped_target_match = NestedMapping()
     d_renamed_reordered_skipped_both_match = NestedMapping()
+    d_renamed_reordered_skipped_both_extra_match = NestedMapping()
 
     rename_indices = {
         "z": ("z1", "z2"),
@@ -24,6 +25,8 @@ def test_remap_items_01():
     }
     reorder_indices = [2, 1, 0]
     reorder_indices_names = (("a", "b", "c"), ("c", "b", "a"))
+    reorder_indices_names_extra = (("a", "b", "c"), ("c", "extra", "b", "a"))
+    reorder_indices_dict = {"from": ("a", "b", "c"), "to": ("c", "b", "a")}
     skip_indices_source = (("1", "z"), ("b",))
     skip_indices_target = (("1", "z2"), ("a",))
 
@@ -47,6 +50,9 @@ def test_remap_items_01():
                     d_renamed_reordered_skipped_both_match["z1", i2new, i1] = c
                     d_renamed_reordered_skipped_both_match["z2", i2new, i1] = c
 
+                    d_renamed_reordered_skipped_both_extra_match["z1", "extra", i2new, i1] = c
+                    d_renamed_reordered_skipped_both_extra_match["z2", "extra", i2new, i1] = c
+
                 d_renamed_reordered_skipped_source_match["z1", i2new, i1] = c
                 d_renamed_reordered_skipped_source_match["z2", i2new, i1] = c
 
@@ -63,6 +69,7 @@ def test_remap_items_01():
                 d_renamed_reordered_skipped_source_match[i3, i2new, i1] = c
                 if i2new != "a":
                     d_renamed_reordered_skipped_both_match[i3, i2new, i1] = c
+                    d_renamed_reordered_skipped_both_extra_match[i3, "extra", i2new, i1] = c
 
     d_new = remap_items(d_main, reorder_indices=reorder_indices)
     assert d_reordered_match == d_new
@@ -73,6 +80,9 @@ def test_remap_items_01():
     d_new = remap_items(d_main, reorder_indices=reorder_indices_names)
     assert d_reordered_match == d_new
 
+    d_new = remap_items(d_main, reorder_indices=reorder_indices_dict)
+    assert d_reordered_match == d_new
+
     d_new = remap_items(
         d_main,
         reorder_indices=reorder_indices,
@@ -122,6 +132,25 @@ def test_remap_items_01():
         skip_indices_source=skip_indices_source,
         skip_indices_target=skip_indices_target,
     )
+    assert d_renamed_reordered_skipped_both_match == d_new
+
+    with raises(ValueError):
+        d_new = remap_items(
+            d_main,
+            rename_indices=rename_indices,
+            reorder_indices=reorder_indices_names_extra,
+            skip_indices_source=skip_indices_source,
+            skip_indices_target=skip_indices_target,
+        )
+    d_new = remap_items(
+        d_main,
+        rename_indices=rename_indices,
+        reorder_indices=reorder_indices_names_extra,
+        skip_indices_source=skip_indices_source,
+        skip_indices_target=skip_indices_target,
+        allow_insert_items=True,
+    )
+    assert d_renamed_reordered_skipped_both_extra_match == d_new
 
     with raises(ValueError):
         remap_items(d_main, reorder_indices=[["a", "b", "c"], ["c", "a", "B"]])
@@ -227,3 +256,19 @@ def test_reorder_function():
 
     with raises(ValueError):
         make_reorder_function([list("abc"), list("cad")])
+
+    with raises(ValueError):
+        fcn6 = make_reorder_function([list("abc"), list("cdab")])
+
+    fcn6 = make_reorder_function([list("abc"), list("cdab")], allow_insert_items=True)
+    data6 = [3, "d", 1, 2]
+    assert data6 == fcn6(data_from)
+
+    with raises(ValueError):
+        fcn6 = make_reorder_function([list("abc"), list("cdb")], allow_insert_items=True)
+
+    fcn6 = make_reorder_function(
+        [list("abc"), list("cdb")], allow_insert_items=True, allow_skip_items=True
+    )
+    data6 = [3, "d", 2]
+    assert data6 == fcn6(data_from)