def _merge_item(d, key, value, overwrite=True, concat=False):
if key in d:
item = d.get(key, None)
if type_util.is_dict(item) and type_util.is_dict(value):
_merge_dict(item, value, overwrite=overwrite, concat=concat)
elif concat and type_util.is_list(item) and type_util.is_list(value):
item += value
elif overwrite:
d[key] = value
else:
d[key] = value
def _get_by_keys(self, keys, default=None):
parent, key, _ = keylist_util.get_item(self, keys)
if type_util.is_dict(parent):
return parent.get(key, default)
elif type_util.is_list(parent):
return parent[key]
return default
def _contains_by_keys(self, keys):
parent, _, _ = keylist_util.get_item(self, keys)
if type_util.is_dict(parent):
return True
elif type_util.is_list(parent):
return True
return False
def _getitem_by_keys(self, keys):
parent, key, _ = keylist_util.get_item(self, keys)
if type_util.is_dict(parent):
return parent[key]
elif type_util.is_list(parent):
return parent[key]
raise KeyError
def _getitem_by_keys(self, keys):
parent, key, _ = keylist_util.get_item(self, keys)
if type_util.is_dict(parent):
return parent[key]
elif type_util.is_list(parent):
return parent[key]
raise KeyError('Invalid keys: "{}"'.format(keys))
def _get_item_key_and_value(item, key):
if type_util.is_list(item):
index = _get_index(key)
if index is not None:
return (index, item[index], )
elif type_util.is_dict(item):
return (key, item[key], )
raise KeyError('Invalid key: "{}"'.format(key))
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):
return parent.pop(key)
if args:
return args[0]
raise KeyError
def _parse_list(val, separator=None):
serializer = JSONSerializer()
try:
l = serializer.decode(val)
if type_util.is_list(l):
return l
except Exception:
if separator:
l = list(val.split(separator))
return l
return None
def groupby(items, key):
if not type_util.is_list(items):
raise ValueError('items should be a list of dicts.')
items_grouped = {}
for item in items:
if not type_util.is_dict(item):
raise ValueError('item should be a dict.')
group = item.get(key)
if group not in items_grouped:
items_grouped[group] = []
items_grouped[group].append(item.copy())
return items_grouped
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):
return parent.pop(key)
elif type_util.is_tuple(parent):
# raise the standard TypeError
del parent[key]
if args:
return args[0]
raise KeyError('Invalid keys: "{}"'.format(keys))
def _parse_list(val, separator=None):
if val.startswith('{') and val.endswith('}') or val.startswith(
'[') and val.endswith(']'):
try:
serializer = JSONSerializer()
l = serializer.decode(val)
if type_util.is_list(l):
return l
return None
except Exception:
pass
if separator:
l = list(val.split(separator))
return l
return None
def _decode(s, format, **kwargs):
try:
content = io_util.read_content(s)
# decode content using the given format
data = io_util.decode(content, format, **kwargs)
if type_util.is_dict(data):
return data
elif type_util.is_list(data):
# force list to dict
return {'values': data}
else:
raise ValueError(
'Invalid data type: {}, expected dict or list.'.format(
type(data)))
except Exception as e:
raise ValueError(
'Invalid data or url or filepath argument: {}\n{}'.format(
s, e))
def _get_keylist_for_value(value, parent_keys, indexes):
if type_util.is_dict(value):
return _get_keylist_for_dict(value, parent_keys, indexes)
elif type_util.is_list(value) and indexes:
return _get_keylist_for_list(value, parent_keys, indexes)
return []