nested-mapping 0.12.1__tar.gz → 0.13.1__tar.gz

{nested_mapping-0.12.1 → nested_mapping-0.13.1}/CHANGELOG.md

@@ -5,10 +5,18 @@ 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.1] - 2026-11-03
+
+- hotfix: print works only with `verbose` mode.
+
+## [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
 
-- fix: update check between of left-handed keys and indices in right-handed keys in `match_keys_to_key`
-- refactor: update code of `match_keys_to_key`
+- feature: extra protection for `match_keys` to avoid keys being skipped. Can be disabled.
 
 ## [0.12.0] - 2026-10-01
 

{nested_mapping-0.12.1/src/nested_mapping.egg-info → nested_mapping-0.13.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: nested-mapping
-Version: 0.12.1
+Version: 0.13.1
 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.1 → nested_mapping-0.13.1}/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.1'
-__version_tuple__ = version_tuple = (0, 12, 1)
+__version__ = version = '0.13.1'
+__version_tuple__ = version_tuple = (0, 13, 1)
 
-__commit_id__ = commit_id = 'g70b286d13'
+__commit_id__ = commit_id = 'gb3fd43ba6'

{nested_mapping-0.12.1 → nested_mapping-0.13.1}/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,10 @@ def remap_items(
                 target[newkey_ordered] = fcn(value)
     else:
         for key, value in source.walkitems():
+            if skip_source(key):
+                if verbose:
+                    print(f"remap: skip {'.'.join(key)}")
+                continue
             newkey_ordered = reorder(key)
             if skip_target(newkey_ordered):
                 if verbose:
@@ -128,39 +129,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.12.1 → nested_mapping-0.13.1}/src/nested_mapping/tools/match.py

@@ -1,7 +1,7 @@
 from __future__ import annotations
 
 from contextlib import suppress
-from typing import TYPE_CHECKING, Any
+from typing import Any, TYPE_CHECKING, TypeVar
 
 from ordered_set import OrderedSet
 
@@ -10,30 +10,36 @@ 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_symmetric(
-    set_key_left: set | OrderedSet, set_key_right: set | OrderedSet
+
+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: set | OrderedSet, set_key_right: set | OrderedSet
-) -> bool:
+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: set | OrderedSet, set_key_right: set | OrderedSet
-) -> bool:
+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: set | OrderedSet,
-    keys_consistent: Callable[[set | OrderedSet, set | OrderedSet], bool],
+    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,
@@ -57,7 +63,7 @@ def match_keys_to_key(
         key_left_tuple = properkey(key_left)
         key_left_set = OrderedSet(key_left_tuple)
 
-        if not keys_consistent(key_left_set, key_right_set):
+        if not keys_consistent_fcn(key_left_set, key_right_set):  # pyright: ignore [reportArgumentType]
             if (
                 collect_skipped_left_keys
                 and key_left_tuple
@@ -100,7 +106,9 @@ def match_keys_to_key(
                 skipped_right_keys.remove(
                     key_right_tuple
                 )  # pyright: ignore [reportOptionalMemberAccess]
-            processed_right_keys.add(key_right_tuple)  # pyright: ignore [reportOptionalMemberAccess]
+            processed_right_keys.add(
+                key_right_tuple
+            )  # pyright: ignore [reportOptionalMemberAccess]
 
     return right_key_processed
 
@@ -108,27 +116,27 @@ def match_keys_to_key(
 def zip_match_keys_to_key(
     keys_left: Sequence[KeyLike],
     key_right_tuple: TupleKey,
-    key_right_set: set | OrderedSet,
-    keys_consistent_fcn: Callable[[set | OrderedSet, set | OrderedSet], bool],
+    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):
+        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[[set | OrderedSet, set | OrderedSet], bool],
+    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
+            keys_left, key_right_tuple, key_right_set, keys_consistent_fcn  # pyright: ignore [reportArgumentType]
         )
 
 

{nested_mapping-0.12.1 → nested_mapping-0.13.1/src/nested_mapping.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: nested-mapping
-Version: 0.12.1
+Version: 0.13.1
 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.1/src/nested_mapping.egg-info/scm_version.json

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

{nested_mapping-0.12.1 → nested_mapping-0.13.1}/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)

{nested_mapping-0.12.1 → nested_mapping-0.13.1}/tests/test_match.py

@@ -1,31 +1,58 @@
 from itertools import product
 
+from ordered_set import OrderedSet
 from pytest import raises
 
 from nested_mapping.tools import match_keys
 from nested_mapping.tools.match import (
     match_keys_to_key,
     set_keys_consistent_left_in_right,
+    set_keys_consistent_ordered,
     set_keys_consistent_right_in_left,
     set_keys_consistent_symmetric,
+    set_keys_consistent_unordered,
     zip_match_keys_to_key,
     zip_match_keys_to_keys,
 )
 
 
 def test_set_keys_consistent():
-    ab = set("ab")
-    abc = set("abc")
-    abce = set("abce")
-    abcd = set("abcd")
-    abd = set("abd")
-    abe = set("abe")
-    ac = set("ac")
-    empty = set()
+    ab = OrderedSet("ab")
+    abc = OrderedSet("abc")
+    abce = OrderedSet("abce")
+    abcd = OrderedSet("abcd")
+    abd = OrderedSet("abd")
+    abe = OrderedSet("abe")
+    ac = OrderedSet("ac")
+    cab = OrderedSet("cab")
+    empty: OrderedSet[str] = OrderedSet(())
+
+    assert set_keys_consistent_ordered(abc, abc) is True
+    assert set_keys_consistent_ordered(ab, abc) is False
+    assert set_keys_consistent_ordered(abc, ac) is False
+    assert set_keys_consistent_ordered(abc, empty) is False
+
+    assert set_keys_consistent_ordered(abc, cab) is False
+    assert set_keys_consistent_ordered(ab, cab) is False
+    assert set_keys_consistent_ordered(cab, ac) is False
+
+    assert set_keys_consistent_unordered(abc, abc) is True
+    assert set_keys_consistent_unordered(ab, abc) is False
+    assert set_keys_consistent_unordered(abc, ac) is False
+    assert set_keys_consistent_unordered(abc, empty) is False
+
+    assert set_keys_consistent_unordered(abc, cab) is True
+    assert set_keys_consistent_unordered(ab, cab) is False
+    assert set_keys_consistent_unordered(cab, ac) is False
+
     assert set_keys_consistent_symmetric(abc, abc) is True
     assert set_keys_consistent_symmetric(ab, abc) is True
     assert set_keys_consistent_symmetric(abc, ac) is True
 
+    assert set_keys_consistent_symmetric(abc, cab) is True
+    assert set_keys_consistent_symmetric(ab, cab) is True
+    assert set_keys_consistent_symmetric(cab, ac) is True
+
     assert set_keys_consistent_symmetric(abcd, abce) is False
     assert set_keys_consistent_symmetric(abd, abce) is False
     assert set_keys_consistent_symmetric(abcd, abe) is False
@@ -36,6 +63,10 @@ def test_set_keys_consistent():
     assert set_keys_consistent_left_in_right(ab, abc) is True
     assert set_keys_consistent_left_in_right(abc, ac) is False
 
+    assert set_keys_consistent_left_in_right(abc, cab) is True
+    assert set_keys_consistent_left_in_right(ab, cab) is True
+    assert set_keys_consistent_left_in_right(cab, ac) is False
+
     assert set_keys_consistent_left_in_right(abcd, abce) is False
     assert set_keys_consistent_left_in_right(abd, abce) is False
     assert set_keys_consistent_left_in_right(abcd, abe) is False
@@ -46,6 +77,10 @@ def test_set_keys_consistent():
     assert set_keys_consistent_right_in_left(ab, abc) is False
     assert set_keys_consistent_right_in_left(abc, ac) is True
 
+    assert set_keys_consistent_right_in_left(abc, cab) is True
+    assert set_keys_consistent_right_in_left(ab, cab) is False
+    assert set_keys_consistent_right_in_left(cab, ac) is True
+
     assert set_keys_consistent_right_in_left(abcd, abce) is False
     assert set_keys_consistent_right_in_left(abd, abce) is False
     assert set_keys_consistent_right_in_left(abcd, abe) is False
@@ -61,42 +96,61 @@ def test_zip_match_keys_to_key():
     abd = tuple("abd")
     abe = tuple("abe")
     ac = tuple("ac")
+    cab = tuple("cab")
     x = tuple("x")
     empty = tuple()
 
     assert list(
         zip_match_keys_to_key(
-            [ab, abc, abce, abcd, abd, abe, ac, empty],
+            [ab, abc, abce, abcd, abd, abe, ac, cab, empty],
             abc,
-            set(abc),
+            OrderedSet(abc),
+            keys_consistent_fcn=set_keys_consistent_ordered,
+        )
+    ) == [(abc, abc)]
+
+    assert list(
+        zip_match_keys_to_key(
+            [ab, abc, abce, abcd, abd, abe, ac, cab, empty],
+            abc,
+            OrderedSet(abc),
+            keys_consistent_fcn=set_keys_consistent_unordered,
+        )
+    ) == [(abc, abc), (cab, abc)]
+
+    assert list(
+        zip_match_keys_to_key(
+            [ab, abc, abce, abcd, abd, abe, ac, cab, empty],
+            abc,
+            OrderedSet(abc),
             keys_consistent_fcn=set_keys_consistent_symmetric,
         )
-    ) == [(ab, abc), (abc, abc), (abce, abc), (abcd, abc), (ac, abc), (empty, abc)]
+    ) == [(ab, abc), (abc, abc), (abce, abc), (abcd, abc), (ac, abc), (cab, abc), (empty, abc)]
 
     assert list(
         zip_match_keys_to_key(
-            [ab, abc, abce, abcd, abd, abe, ac, empty],
+            [ab, abc, abce, abcd, abd, abe, ac, cab, empty],
             abc,
-            set(abc),
+            OrderedSet(abc),
             keys_consistent_fcn=set_keys_consistent_left_in_right,
         )
-    ) == [(ab, abc), (abc, abc), (ac, abc), (empty, abc)]
+    ) == [(ab, abc), (abc, abc), (ac, abc), (cab, abc), (empty, abc)]
 
     assert list(
         zip_match_keys_to_key(
-            [ab, abc, abce, abcd, abd, abe, ac, empty],
+            [ab, abc, abce, abcd, abd, abe, ac, cab, empty],
             abc,
-            set(abc),
+            OrderedSet(abc),
             keys_consistent_fcn=set_keys_consistent_right_in_left,
         )
-    ) == [(abc, abc), (abce, abc), (abcd, abc)]
+    ) == [(abc, abc), (abce, abc), (abcd, abc), (cab, abc)]
 
     assert (
         list(
             zip_match_keys_to_key(
                 [ab, abc, abce, abcd, abd, abe, ac],
                 x,
-                set(x),
+                OrderedSet(x),
                 keys_consistent_fcn=set_keys_consistent_symmetric,
             )
         )
@@ -112,12 +166,36 @@ def test_zip_match_keys_to_keys():
     abd = tuple("abd")
     abe = tuple("abe")
     ac = tuple("ac")
+    cab = tuple("cab")
     x = tuple("x")
     empty = tuple()
 
     assert list(
         zip_match_keys_to_keys(
-            [ab, abc, abce, abcd, abd, abe, ac, empty],
+            [ab, abc, abce, abcd, abd, abe, ac, cab, empty],
+            [abc, abd, x],
+            keys_consistent_fcn=set_keys_consistent_ordered,
+        )
+    ) == [
+        (abc, abc),
+        (abd, abd),
+    ]
+
+    assert list(
+        zip_match_keys_to_keys(
+            [ab, abc, abce, abcd, abd, abe, ac, cab, empty],
+            [abc, abd, x],
+            keys_consistent_fcn=set_keys_consistent_unordered,
+        )
+    ) == [
+        (abc, abc),
+        (cab, abc),
+        (abd, abd),
+    ]
+
+    assert list(
+        zip_match_keys_to_keys(
+            [ab, abc, abce, abcd, abd, abe, ac, cab, empty],
             [abc, abd, x],
             keys_consistent_fcn=set_keys_consistent_symmetric,
         )
@@ -127,6 +205,7 @@ def test_zip_match_keys_to_keys():
         (abce, abc),
         (abcd, abc),
         (ac, abc),
+        (cab, abc),
         (empty, abc),
         (ab, abd),
         (abcd, abd),
@@ -137,7 +216,7 @@ def test_zip_match_keys_to_keys():
 
     assert list(
         zip_match_keys_to_keys(
-            [ab, abc, abce, abcd, abd, abe, ac, empty],
+            [ab, abc, abce, abcd, abd, abe, ac, cab, empty],
             [abc, abd, x],
             keys_consistent_fcn=set_keys_consistent_left_in_right,
         )
@@ -145,6 +224,7 @@ def test_zip_match_keys_to_keys():
         (ab, abc),
         (abc, abc),
         (ac, abc),
+        (cab, abc),
         (empty, abc),
         (ab, abd),
         (abd, abd),
@@ -154,7 +234,7 @@ def test_zip_match_keys_to_keys():
 
     assert list(
         zip_match_keys_to_keys(
-            [ab, abc, abce, abcd, abd, abe, ac, empty],
+            [ab, abc, abce, abcd, abd, abe, ac, cab, empty],
             [abc, abd, x],
             keys_consistent_fcn=set_keys_consistent_right_in_left,
         )
@@ -162,6 +242,7 @@ def test_zip_match_keys_to_keys():
         (abc, abc),
         (abce, abc),
         (abcd, abc),
+        (cab, abc),
         (abcd, abd),
         (abd, abd),
     ]
@@ -175,6 +256,7 @@ def test_match_keys_to_key():
     abd = tuple("abd")
     abe = tuple("abe")
     ac = tuple("ac")
+    cab = tuple("cab")
     x = tuple("x")
     empty = tuple()
 
@@ -224,17 +306,86 @@ def test_match_keys_to_key():
         skipped_right_keys,
         processed_right_keys,
     ) = call_match(
-        [ab, abc, abce, abcd, abd, abe, ac, empty],
+        [ab, abc, abce, abcd, abd, abe, ac, cab, empty],
         abc,
-        set(abc),
+        OrderedSet(abc),
+        set_keys_consistent_ordered,
+    )
+    assert right_processed == True
+    assert processed == [(abc, abc)]
+    assert skipped == [
+        (ab, abc),
+        (abce, abc),
+        (abcd, abc),
+        (abd, abc),
+        (abe, abc),
+        (ac, abc),
+        (cab, abc),
+        (empty, abc),
+    ]
+    assert skipped_left_keys == {ab, abce, abcd, abd, abe, ac, cab, empty}
+    assert processed_left_keys == {abc}
+    assert skipped_right_keys == OrderedSet(())
+    assert processed_right_keys == {abc}
+
+    (
+        right_processed,
+        processed,
+        skipped,
+        skipped_left_keys,
+        processed_left_keys,
+        skipped_right_keys,
+        processed_right_keys,
+    ) = call_match(
+        [ab, abc, abce, abcd, abd, abe, ac, cab, empty],
+        abc,
+        OrderedSet(abc),
+        set_keys_consistent_unordered,
+    )
+    assert right_processed == True
+    assert processed == [(abc, abc), (cab, abc)]
+    assert skipped == [
+        (ab, abc),
+        (abce, abc),
+        (abcd, abc),
+        (abd, abc),
+        (abe, abc),
+        (ac, abc),
+        (empty, abc),
+    ]
+    assert skipped_left_keys == {ab, abce, abcd, abd, abe, ac, empty}
+    assert processed_left_keys == {abc, cab}
+    assert skipped_right_keys == OrderedSet(())
+    assert processed_right_keys == {abc}
+
+    (
+        right_processed,
+        processed,
+        skipped,
+        skipped_left_keys,
+        processed_left_keys,
+        skipped_right_keys,
+        processed_right_keys,
+    ) = call_match(
+        [ab, abc, abce, abcd, abd, abe, ac, cab, empty],
+        abc,
+        OrderedSet(abc),
         set_keys_consistent_symmetric,
     )
     assert right_processed == True
-    assert processed == [(ab, abc), (abc, abc), (abce, abc), (abcd, abc), (ac, abc), (empty, abc)]
+    assert processed == [
+        (ab, abc),
+        (abc, abc),
+        (abce, abc),
+        (abcd, abc),
+        (ac, abc),
+        (cab, abc),
+        (empty, abc),
+    ]
     assert skipped == [(abd, abc), (abe, abc)]
     assert skipped_left_keys == {abd, abe}
-    assert processed_left_keys == {ab, abc, abce, abcd, ac, empty}
-    assert skipped_right_keys == set()
+    assert processed_left_keys == {ab, abc, abce, abcd, ac, cab, empty}
+    assert skipped_right_keys == OrderedSet(())
     assert processed_right_keys == {abc}
 
     (
@@ -248,7 +399,7 @@ def test_match_keys_to_key():
     ) = call_match(
         [ab, abc, abce, abcd, abd, abe, ac, empty],
         abc,
-        set(abc),
+        OrderedSet(abc),
         set_keys_consistent_left_in_right,
     )
     assert right_processed == True
@@ -256,7 +407,7 @@ def test_match_keys_to_key():
     assert skipped == [(abce, abc), (abcd, abc), (abd, abc), (abe, abc)]
     assert skipped_left_keys == {abd, abce, abcd, abe}
     assert processed_left_keys == {ab, abc, ac, empty}
-    assert skipped_right_keys == set()
+    assert skipped_right_keys == OrderedSet(())
     assert processed_right_keys == {abc}
 
     (
@@ -270,7 +421,7 @@ def test_match_keys_to_key():
     ) = call_match(
         [ab, abc, abce, abcd, abd, abe, ac, empty],
         abc,
-        set(abc),
+        OrderedSet(abc),
         set_keys_consistent_right_in_left,
     )
     assert right_processed == True
@@ -278,7 +429,7 @@ def test_match_keys_to_key():
     assert skipped == [(ab, abc), (abd, abc), (abe, abc), (ac, abc), (empty, abc)]
     assert skipped_left_keys == {ab, abd, abe, ac, empty}
     assert processed_left_keys == {abc, abce, abcd}
-    assert skipped_right_keys == set()
+    assert skipped_right_keys == OrderedSet(())
     assert processed_right_keys == {abc}
 
     (
@@ -292,16 +443,16 @@ def test_match_keys_to_key():
     ) = call_match(
         [ab, abc, abce, abcd, abd, abe, ac],
         x,
-        set(x),
+        OrderedSet(x),
         set_keys_consistent_symmetric,
     )
     assert right_processed == False
     assert processed == []
     assert skipped == [(ab, x), (abc, x), (abce, x), (abcd, x), (abd, x), (abe, x), (ac, x)]
     assert skipped_left_keys == {ab, abc, abce, abcd, abd, abe, ac}
-    assert processed_left_keys == set()
+    assert processed_left_keys == OrderedSet(())
     assert skipped_right_keys == {x}
-    assert processed_right_keys == set()
+    assert processed_right_keys == OrderedSet(())
 
     with raises(ValueError):
         (
@@ -315,7 +466,7 @@ def test_match_keys_to_key():
         ) = call_match(
             [ab, abc, abc, abce, abcd, abd, abe, ac, empty],
             abc,
-            set(abc),
+            OrderedSet(abc),
             set_keys_consistent_symmetric,
             require_no_duplicate_right_matches=True,
         )
@@ -544,7 +695,7 @@ def test_match_1():
         require_all_left_keys_processed=True,
         require_all_right_keys_processed=True,
         require_all_left_keys_match_right=False,
-        unmatched_right_keys_should_contain=[("2",)]
+        unmatched_right_keys_should_contain=[("2",)],
     )
     assert processed == [
         (0, a, a1x),
@@ -585,7 +736,7 @@ def test_match_1():
             require_all_left_keys_processed=True,
             require_all_right_keys_processed=True,
             require_all_left_keys_match_right=False,
-            unmatched_right_keys_should_contain=[("2", "a")]
+            unmatched_right_keys_should_contain=[("2", "a")],
         )
     (
         processed,
@@ -598,7 +749,7 @@ def test_match_1():
         require_all_left_keys_processed=True,
         require_all_right_keys_processed=True,
         require_all_left_keys_match_right=False,
-        unmatched_right_keys_should_contain=[("2", "a"), ("b", "2")]
+        unmatched_right_keys_should_contain=[("2", "a"), ("b", "2")],
     )
     assert processed == [
         (0, a, a1x),

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

@@ -1,8 +0,0 @@
-{
-  "tag": "0.12.1",
-  "distance": 0,
-  "node": "g70b286d139ee9177b2886dfbe9a73efe2e19880a",
-  "dirty": false,
-  "branch": "HEAD",
-  "node_date": "2026-10-29"
-}