benedict.dicts.keylist.keylist_dict

Complexity

Total Complexity

51

Size/Duplication

Total Lines	126
Duplicated Lines	0 %

Importance

Changes

0

15 Methods

Rating	Name	Duplication	Size	Complexity
A	KeylistDict.__contains__()	0	4	2
A	KeylistDict.__init__()	0	2	1
A	KeylistDict.__delitem__()	0	5	2
A	KeylistDict._contains_by_keys()	0	5	2
A	KeylistDict.__getitem__()	0	4	2
A	KeylistDict._delitem_by_keys()	0	12	4
A	KeylistDict.__setitem__()	0	5	2
B	KeylistDict._getitem_by_keys()	0	14	8
A	KeylistDict.get()	0	4	2
A	KeylistDict._setitem_by_keys()	0	2	1
A	KeylistDict.pop()	0	4	2
C	KeylistDict._get_by_keys()	0	16	10
A	KeylistDict.set()	0	2	1
A	KeylistDict.setdefault()	0	5	2
C	KeylistDict._pop_by_keys()	0	18	10

# -*- coding: utf-8 -*-
from itertools import chain

from benedict.dicts.base import BaseDict
from benedict.dicts.keylist import keylist_util
from benedict.utils import type_util


class KeylistDict(BaseDict):
    def __init__(self, *args, **kwargs):
        super(KeylistDict, self).__init__(*args, **kwargs)

    def __contains__(self, key):
        if type_util.is_list_or_tuple(key):
            return self._contains_by_keys(key)
        return super(KeylistDict, self).__contains__(key)

    def _contains_by_keys(self, keys):
        parent, _, _ = keylist_util.get_item(self, keys)
        if type_util.is_dict_or_list_or_tuple(parent):
            return True
        return False

    def __delitem__(self, key):
        if type_util.is_list_or_tuple(key):
            self._delitem_by_keys(key)
            return
        super(KeylistDict, self).__delitem__(key)

    def _delitem_by_keys(self, keys):
        parent, key, _ = keylist_util.get_item(self, keys)
        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):
            # raise the standard TypeError
            del parent[key]
        raise KeyError(f"Invalid keys: '{keys}'")

    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 _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
        elif type_util.is_list_of_dicts(parent) and type_util.any_wildcard_in_list(
            keys
        ):
            data = [item.get(key) for item in parent]
            if type_util.is_list_of_dicts(data) or type_util.is_list_of_list(data):
                return list(chain.from_iterable(data))
            return data
        elif type_util.is_dict_or_list_or_tuple(parent):
            return parent[key]
        raise KeyError(f"Invalid keys: '{keys}'")

    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 _setitem_by_keys(self, keys, value):
        keylist_util.set_item(self, keys, value)

    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 _get_by_keys(self, keys, default=None):
        parent, key, value = keylist_util.get_item(self, keys)
        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]
        return default

    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 _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):
            return [parent.pop(index) for index in [0] * len(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):
            # raise the standard TypeError
            del parent[key]
        if args:
            return args[0]
        raise KeyError(f"Invalid keys: '{keys}'")

    def set(self, key, value):
        self[key] = value

    def setdefault(self, key, default=None):
        if key not in self:
            self[key] = default
            return default
        return self[key]