List wildcard

benedict/__init__.py

@@ -1,5 +1,4 @@
 # -*- coding: utf-8 -*-
-
 from benedict.dicts import benedict
 from benedict.metadata import (
     __author__,

benedict/dicts/__init__.py

@@ -194,9 +194,9 @@ def match(self, pattern, indexes=True):
     def merge(self, other, *args, **kwargs):
         """
         Merge one or more dict objects into current instance (deepupdate).
-        Sub-dictionaries will be merged toghether.
+        Sub-dictionaries will be merged together.
         If overwrite is False, existing values will not be overwritten.
-        If concat is True, list values will be concatenated toghether.
+        If concat is True, list values will be concatenated together.
         """
         _merge(self, other, *args, **kwargs)
 
@@ -212,7 +212,7 @@ def nest(
     ):
         """
         Nest a list of dicts at the given key and return a new nested list
-        using the specified keys to establish the correct items hierarchy.
+        using the specified keys to establish the correct item's hierarchy.
         """
         return _nest(self[key], id_key, parent_id_key, children_key)
 

benedict/dicts/keylist/keylist_dict.py

@@ -43,6 +43,8 @@ def __getitem__(self, key):
 
     def _getitem_by_keys(self, keys):
         parent, key, _ = keylist_util.get_item(self, keys)
+        if type_util.is_list_of_dicts(parent) and any(type_util.is_wildcard(_key) for _key in keys):
+            return [item.get(key) for item in parent]
         if type_util.is_dict_or_list_or_tuple(parent):
             return parent[key]
         raise KeyError(f"Invalid keys: '{keys}'")
@@ -78,6 +80,11 @@ def _pop_by_keys(self, keys, *args):
         parent, key, _ = keylist_util.get_item(self, keys)
         if type_util.is_dict(parent):
             return parent.pop(key, *args)
+        elif (
+            type_util.is_list_of_dicts(parent)
+            and any(type_util.is_wildcard(_key) for _key in keys)
+        ):
+            return [_item.pop(key) if key in _item else None for _item in parent]
         elif type_util.is_list(parent):
             return parent.pop(key)
         elif type_util.is_tuple(parent):

benedict/dicts/keylist/keylist_util.py

@@ -9,14 +9,23 @@ def _get_index(key):
     return None
 
 
-def _get_item_key_and_value(item, key):
+def _get_item_key_and_value(item, index, parent=None):
     if type_util.is_list_or_tuple(item):
-        index = _get_index(key)
-        if index is not None:
-            return (index, item[index])
+        if type_util.is_wildcard(index):
+            return index, item
+        elif (
+            type_util.is_wildcard(parent)
+            and type_util.is_list_of_dicts(item)
+            and any(index in _item.keys() for _item in item)
+        ):
+            return index, [_item for _item in item if index in _item.keys()]
+        else:
+            index = _get_index(index)
+            if index is not None:
+                return index, item[index]
     elif type_util.is_dict(item):
-        return (key, item[key])
-    raise KeyError(f"Invalid key: '{key}'")
+        return index, item[index]
+    raise KeyError(f"Invalid key: '{index}'")
 
 
 def _get_or_new_item_value(item, key, subkey):
@@ -45,6 +54,10 @@ def _set_item_value(item, key, value):
             # insert index
             item += [None] * (index - len(item))
             item.insert(index, value)
+    elif type_util.is_list(item):
+        for idx, _item in enumerate(value):
+            if _item is not None:
+                item[idx].update({key: _item})
     else:
         item[key] = value
 
@@ -59,7 +72,16 @@ def get_items(d, keys):
     item = d
     for key in keys:
         try:
-            item_key, item_value = _get_item_key_and_value(item, key)
+            if any(items):
+                if type_util.is_wildcard(val=key):
+                    parent = items[-1][1]
+                elif type_util.is_wildcard(items[-1][1]):
+                    parent = items[-1][1]
+                else:
+                    parent = None
+            else:
+                parent = None
+            item_key, item_value = _get_item_key_and_value(item, key, parent)
             items.append((item, item_key, item_value))
             item = item_value
         except (IndexError, KeyError):

benedict/dicts/keypath/keypath_util.py

@@ -7,6 +7,7 @@
 
 
 KEY_INDEX_RE = r"(?:\[[\'\"]*(\-?[\d]+)[\'\"]*\]){1}$"
+KEY_WILDCARD_RE = r"(?:\[[\'\"]*(\-?[\*]+)[\'\"]*\]){1}$"
 
 
 def check_keys(d, separator):
@@ -45,12 +46,17 @@ def _split_key_indexes(key):
     if "[" in key and key.endswith("]"):
         keys = []
         while True:
-            matches = re.findall(KEY_INDEX_RE, key)
-            if matches:
+            index_matches = re.findall(KEY_INDEX_RE, key)
+            if index_matches:
                 key = re.sub(KEY_INDEX_RE, "", key)
-                index = int(matches[0])
+                index = int(index_matches[0])
+                keys.insert(0, index)
+                continue
+            index_matches = re.findall(KEY_WILDCARD_RE, key)
+            if bool(re.search(KEY_WILDCARD_RE, key)):
+                key = re.sub(KEY_WILDCARD_RE, "", key)
+                index = index_matches[0]
                 keys.insert(0, index)
-                # keys.insert(0, { keylist_util.INDEX_KEY:index })
                 continue
             keys.insert(0, key)
             break

benedict/utils/type_util.py

@@ -91,3 +91,11 @@ def is_tuple(val):
 
 def is_uuid(val):
     return is_string(val) and uuid_re.match(val)
+
+
+def is_wildcard(val):
+    return is_string(val) and val == "*"
+
+
+def is_list_of_dicts(val):
+    return is_list(val) and all(is_dict(_val) for _val in val)

tests/dicts/keypath/test_keypath_dict_list_wildcard.py

@@ -0,0 +1,23 @@
+import unittest
+
+from benedict.dicts import KeypathDict
+
+
+class keypath_dict_list_wildcard_test_case(unittest.TestCase):
+    def setUp(self):
+        self.blueprint = KeypathDict(
+            {
+                "a": [
+                    {"x": 1, "y": 1},
+                    {"x": 2, "y": 2},
+                ],
+                "x": [
+                    {"a": 10, "b": 10},
+                    {"a": 11, "b": 11},
+                ],
+            }
+        )
+
+    def test_correct_wildcard(self):
+        correct_wildcard_path_example = "a[*].x"
+        self.assertEqual(self.blueprint[correct_wildcard_path_example], [1, 2])

tests/dicts/keypath/test_keypath_util.py

@@ -30,7 +30,6 @@ def test_split_key_indexes_with_valid_indexes(self):
     def test_split_key_indexes_with_invalid_indexes(self):
         f = keypath_util._split_key_indexes
         self.assertEqual(f("item[]"), ["item[]"])
-        self.assertEqual(f("item[*]"), ["item[*]"])
         self.assertEqual(f("item[0:2]"), ["item[0:2]"])
         self.assertEqual(f("item[:1]"), ["item[:1]"])
         self.assertEqual(f("item[::1]"), ["item[::1]"])

tests/dicts/test_benedict_wildcard.py

@@ -0,0 +1,61 @@
+import unittest
+
+from benedict import benedict
+
+
+class keypath_dict_list_wildcard_test_case(unittest.TestCase):
+    def test_rename_wildcard(self):
+        d = {
+            "a": [
+                {"x": 1, "y": 1},
+                {"x": 2, "y": 2},
+            ],
+        }
+        d = benedict(d)
+        b = benedict(d.clone())
+        b.rename("a[0].x", "a[0].m")
+        b.rename("a[1].x", "a[1].m")
+
+        result = {
+            "a": [
+                {
+                    "m": 1,
+                    "y": 1,
+                },
+                {
+                    "m": 2,
+                    "y": 2,
+                },
+            ]
+        }
+
+        self.assertEqual(b, result)
+        b = benedict(d.clone())
+        b.rename("a[*].x", "a[*].m")
+        self.assertEqual(b, result)
+
+    def test_swap_wildcard(self):
+        d = {
+            "a": [
+                {"x": 1, "y": 1},
+                {"x": 2, "y": 2},
+            ],
+            "x": [
+                {"a": 10, "b": 10},
+                {"a": 11, "b": 11},
+            ],
+        }
+        b = benedict(d)
+        b = benedict(b.clone())
+        b.swap("a[*].x", "x[*].a")
+        result = {
+            "a": [
+                {"x": 10, "y": 1},
+                {"x": 11, "y": 2},
+            ],
+            "x": [
+                {"a": 1, "b": 10},
+                {"a": 2, "b": 11},
+            ],
+        }
+        self.assertEqual(b, result)