List wildcard

.gitignore

@@ -121,3 +121,6 @@ dmypy.json
 
 # Pyre type checker
 .pyre/
+
+# JetBrains IDEs
+.idea/

benedict/__init__.py

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

benedict/dicts/__init__.py

@@ -195,9 +195,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)
 
@@ -213,7 +213,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

@@ -2,6 +2,7 @@
 
 from benedict.dicts.base import BaseDict
 from benedict.dicts.keylist import keylist_util
+from benedict.dicts.keylist.keylist_util import generator_to_list, pop_in_generator
 from benedict.utils import type_util
 
 
@@ -28,7 +29,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_dict_or_list(parent) and type_util.is_wildcard(key):
+            parent.clear()
+            return
+        elif type_util.is_dict_or_list(parent):
             del parent[key]
             return
         elif type_util.is_tuple(parent):
@@ -42,8 +46,12 @@ def __getitem__(self, key):
         return super(KeylistDict, self).__getitem__(key)
 
     def _getitem_by_keys(self, keys):
-        parent, key, _ = keylist_util.get_item(self, keys)
-        if type_util.is_dict_or_list_or_tuple(parent):
+        parent, key, val = keylist_util.get_item(self, keys)
+        if type_util.is_generator(val):
+            return generator_to_list(val)
+        elif type_util.is_list(parent) and type_util.is_wildcard(key):
+            return parent
+        elif type_util.is_dict_or_list_or_tuple(parent):
             return parent[key]
         raise KeyError(f"Invalid keys: '{keys}'")
 
@@ -62,8 +70,22 @@ def get(self, key, default=None):
         return super(KeylistDict, self).get(key, default)
 
     def _get_by_keys(self, keys, default=None):
-        parent, key, _ = keylist_util.get_item(self, keys)
-        if type_util.is_dict(parent):
+        parent, key, value = keylist_util.get_item(self, keys)
+        if type_util.is_generator(value) and type_util.is_generator(parent):
+            data = generator_to_list(value)
+            if type_util.is_integer(key):
+                return data[key]
+            return data
+        if type_util.is_list_of_list(parent) and type_util.is_wildcard(key):
+            return value
+        elif 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 value
+        elif type_util.is_dict(parent):
             return parent.get(key, default)
         elif type_util.is_list_or_tuple(parent):
             return parent[key]
@@ -75,9 +97,14 @@ def pop(self, key, *args):
         return super(KeylistDict, self).pop(key, *args)
 
     def _pop_by_keys(self, keys, *args):
-        parent, key, _ = keylist_util.get_item(self, keys)
+        parent, key, val = keylist_util.get_item(self, keys)
         if type_util.is_dict(parent):
             return parent.pop(key, *args)
+        elif type_util.is_generator(val) and type_util.is_generator(parent):
+            return pop_in_generator(key, parent)
+        elif type_util.is_wildcard(key):
+            data = [parent.pop(0) for _ in range(len(parent))]
+            return data
         elif type_util.is_list(parent):
             return parent.pop(key)
         elif type_util.is_tuple(parent):

benedict/dicts/keylist/keylist_util.py

@@ -1,4 +1,5 @@
 # -*- coding: utf-8 -*-
+from itertools import chain
 
 from benedict.utils import type_util
 
@@ -9,14 +10,71 @@ def _get_index(key):
     return None
 
 
-def _get_item_key_and_value(item, key):
-    if type_util.is_list_or_tuple(item):
-        index = _get_index(key)
-        if index is not None:
-            return (index, item[index])
+def low_level_generator(item, index):
+    for _item in item:
+        if not type_util.is_dict_or_list_or_tuple(_item):
+            yield _item
+        elif type_util.is_list(_item):
+            for __item in _item:
+                if index in __item:
+                    yield __item.get(index)
+                elif __item:
+                    yield __item
+        elif type_util.is_dict(_item) and index in _item:
+            yield _item[index]
+
+
+def generator_to_list(generator):
+    new_list = []
+    for item in generator:
+        if type_util.is_list_or_tuple(item):
+            new_list.extend(item)
+        else:
+            new_list.append(item)
+    return new_list
+
+
+def _get_item_key_and_value_for_parent_wildcard(item, index):
+    if type_util.is_list_of_dicts(item) and any(
+        index in _item.keys() for _item in item
+    ):
+        return index, low_level_generator(item, index)
+    elif type_util.is_list_of_list(item):
+        if type_util.is_integer(index):
+            data = [_item[index] for _item in item if index < len(_item)]
+            return index, data
+        elif type_util.is_wildcard(index):
+            data = list(chain.from_iterable(item))
+            return index, data
+        else:
+            data = [
+                _item.get(index)
+                for _item in chain.from_iterable(item)
+                if index in _item.keys()
+            ]
+            return index, data
+    elif type_util.is_wildcard(index):
+        return index, item
+    return index, None
+
+
+def _get_item_key_and_value(item, index, parent=None):
+    if type_util.is_generator(item):
+        return index, low_level_generator(item, index)
+    elif type_util.is_list_or_tuple(item):
+        if type_util.is_wildcard(parent):
+            index, item = _get_item_key_and_value_for_parent_wildcard(item, index)
+            if item:
+                return index, item
+        elif type_util.is_wildcard(index):
+            return index, item
+        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 +103,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,12 +121,17 @@ 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):
+                parent = items[-1][1]
+            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):
             items.append((None, None, None))
             break
+
     return items
 
 
@@ -80,3 +147,14 @@ def set_item(d, keys, value):
             continue
         _set_item_value(item, key, value)
         break
+
+
+def pop_in_generator(key, parent):
+    cleaned_list = []
+    for item in parent:
+        if type_util.is_list_or_tuple(item):
+            if type_util.is_wildcard(key):
+                cleaned_list.extend(item.pop(0) for _ in range(len(item)))
+        elif type_util.is_dict(item):
+            cleaned_list.append(item)
+    return cleaned_list

benedict/dicts/keypath/keypath_util.py

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

@@ -1,6 +1,7 @@
 # -*- coding: utf-8 -*-
 
 import re
+import types
 from datetime import datetime
 from decimal import Decimal
 
@@ -90,3 +91,35 @@ 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)
+
+
+def is_generator(val):
+    return isinstance(val, types.GeneratorType)
+
+
+def is_generator_empty(val):
+    """
+    this function should be used only to check if generator contains any data
+    don't use it if you want to use any potential data contained in generator
+
+    val: object
+
+    return: bool
+    """
+    return any(list(val))