Wildcard

benedict/dicts/__init__.py

@@ -191,9 +191,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)
 
@@ -209,7 +209,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

@@ -26,7 +26,10 @@ def __delitem__(self, key):
 
     def _delitem_by_keys(self, keys):
         parent, key, _ = keylist_util.get_item(self, keys)
-        if type_util.is_dict_or_list(parent):
+        if type_util.is_wildcard(key):
+            self[keys[:-1]].clear()
+            return
+        elif type_util.is_dict_or_list(parent):
             del parent[key]
             return
         elif type_util.is_tuple(parent):
@@ -41,6 +44,10 @@ def __getitem__(self, key):
 
     def _getitem_by_keys(self, keys):
         parent, key, _ = keylist_util.get_item(self, keys)
+        if type_util.is_list(parent) and type_util.is_wildcard(key):
+            return parent
+        if type_util.is_list_of_dicts(parent) and type_util.any_wildcard_in_list(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}'")
@@ -61,7 +68,14 @@ def get(self, key, default=None):
 
     def _get_by_keys(self, keys, default=None):
         parent, key, _ = keylist_util.get_item(self, keys)
-        if type_util.is_dict(parent):
+        if type_util.is_list(parent) and type_util.is_wildcard(key):
+            return parent
+        elif type_util.is_wildcard(keys[-2]):
+            if type_util.is_list_of_dicts(parent):
+                return [item.get(key) for item in parent]
+            elif type_util.is_list_of_list(parent):
+                return _
+        elif type_util.is_dict(parent):
             return parent.get(key, default)
         elif type_util.is_list_or_tuple(parent):
             return parent[key]
@@ -76,6 +90,13 @@ 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(parent) and type_util.is_wildcard(key):
+            del self[keys[:-1]]
+            return parent
+        elif type_util.is_list_of_dicts(parent) and type_util.any_wildcard_in_list(
+            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

@@ -1,3 +1,5 @@
+from itertools import chain
+
 from benedict.utils import type_util
 
 
@@ -7,14 +9,30 @@ 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):
+            if type_util.is_list_of_dicts(item) and any(
+                index in _item.keys() for _item in item
+            ):
+                return index, [
+                    _item.get(index) for _item in item if index in _item.keys()
+                ]
+            elif type_util.is_list_of_list(item):
+                return index, [
+                    _item.get(index)
+                    for _item in chain.from_iterable(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):
@@ -43,6 +61,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
 
@@ -57,7 +79,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

@@ -4,6 +4,7 @@
 from benedict.utils import type_util
 
 KEY_INDEX_RE = r"(?:\[[\'\"]*(\-?[\d]+)[\'\"]*\]){1}$"
+KEY_WILDCARD_RE = r"(?:\[[\'\"]*(\-?[\*]+)[\'\"]*\]){1}$"
 
 
 def check_keys(d, separator):
@@ -42,12 +43,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

@@ -93,3 +93,19 @@ 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)
+
+
+def any_wildcard_in_list(val):
+    return is_list(val) and any(is_wildcard(_val) for _val in val)
+
+
+def is_list_of_list(val):
+    return is_list(val) and all(is_list(_val) for _val in val)