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_or_tuple(parent):
return parent[key]
return default
def _get_value(self, key, default, choices,
parser_func, parser_kwargs=None):
"""
Get value by key, or keypath core method.
If choices and value is in choices return value otherwise default.
"""
# Get raw value from self.
value = self.get(key, None)
# If value is None return default value.
if value is None:
return default
# If not of the desired type, try to parse it using parser_func.
value = parser_func(value, **(parser_kwargs or {}))
# If value is None after parsing return default value.
if value is None:
return default
# If choices and value in choices return value otherwise default.
if type_util.is_list_or_tuple(choices) and len(choices) and \
value not in choices:
return default
return value
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])
elif type_util.is_dict(item):
return (key, item[key])
raise KeyError('Invalid key: "{}"'.format(key))
def invert(d, flat=False):
new_dict = clone(d, empty=True)
for key, value in d.items():
if type_util.is_list_or_tuple(value):
_invert_list(new_dict, key, value, flat)
else:
_invert_item(new_dict, key, value, flat)
return new_dict
def invert(d, flat=False):
new_dict = d.copy()
new_dict.clear()
for key, value in d.items():
if type_util.is_list_or_tuple(value):
_invert_list(new_dict, key, value, flat)
else:
_invert_item(new_dict, key, value, flat)
return new_dict
def parse_keys(keypath, separator):
"""
Parse keys from keylist or keypath using the given separator.
"""
if type_util.is_list_or_tuple(keypath):
keys = []
for key in keypath:
keys += parse_keys(key, separator)
return keys
return _split_keys_and_indexes(keypath, separator)
def parse_list(val, separator=None):
val = _parse_with(val,
type_util.is_list_or_tuple,
_parse_list,
separator=separator)
return list(val) if type_util.is_list_or_tuple(val) else val
def pop(self, key, *args):
if type_util.is_list_or_tuple(key):
return self._pop_by_keys(key, *args)
return super(KeylistDict, self).pop(key, *args)
def get(self, key, default=None):
if type_util.is_list_or_tuple(key):
return self._get_by_keys(key, default)
return super(KeylistDict, self).get(key, default)
def __setitem__(self, key, value):
if type_util.is_list_or_tuple(key):
self._setitem_by_keys(key, value)
return
super(KeylistDict, self).__setitem__(key, value)
def __getitem__(self, key):
if type_util.is_list_or_tuple(key):
return self._getitem_by_keys(key)
return super(KeylistDict, self).__getitem__(key)
def __contains__(self, key):
if type_util.is_list_or_tuple(key):
return self._contains_by_keys(key)
return super(KeylistDict, self).__contains__(key)
