benedict.dicts.keypath.keypath_dict

Complexity

Total Complexity

16

Size/Duplication

Total Lines	63
Duplicated Lines	0 %

Importance

Changes

0

11 Methods

Rating	Name	Duplication	Size	Complexity
A	KeypathDict.keypath_separator()	0	3	1
A	KeypathDict.__delitem__()	0	2	1
A	KeypathDict.__getitem__()	0	2	1
A	KeypathDict.__contains__()	0	2	1
A	KeypathDict.update()	0	3	1
A	KeypathDict.get()	0	2	1
A	KeypathDict.pop()	0	2	1
A	KeypathDict._parse_key()	0	8	3
A	KeypathDict.__setitem__()	0	3	1
A	KeypathDict.__init__()	0	6	2
A	KeypathDict.fromkeys()	0	6	2

from benedict.dicts import KeylistDict
from benedict.dicts.keypath import keypath_util


class KeypathDict(KeylistDict):

    _keypath_separator = None

    def __init__(self, *args, **kwargs):
        self._keypath_separator = kwargs.pop("keypath_separator", ".")
        check_keys = kwargs.pop("check_keys", True)
        super().__init__(*args, **kwargs)
        if check_keys:
            keypath_util.check_keys(self, self._keypath_separator)

    @property
    def keypath_separator(self):
        return self._keypath_separator

    @keypath_separator.setter
    def keypath_separator(self, value):
        keypath_util.check_keys(self, value)
        self._keypath_separator = value

    def __contains__(self, key):
        return super().__contains__(self._parse_key(key))

    def __delitem__(self, key):
        super().__delitem__(self._parse_key(key))

    def __getitem__(self, key):
        return super().__getitem__(self._parse_key(key))

    def __setitem__(self, key, value):
        keypath_util.check_keys(value, self._keypath_separator)
        super().__setitem__(self._parse_key(key), value)

    def _parse_key(self, key):
        keys = keypath_util.parse_keys(key, self._keypath_separator)
        keys_count = len(keys)
        if keys_count == 0:
            return None
        elif keys_count == 1:
            return keys[0]
        return keys

    @classmethod
    def fromkeys(cls, sequence, value=None):
        d = cls()
        for key in sequence:
            d[key] = value
        return d

    def get(self, key, default=None):
        return super().get(self._parse_key(key), default)

    def pop(self, key, *args):
        return super().pop(self._parse_key(key), *args)

    def update(self, other):
        keypath_util.check_keys(other, self._keypath_separator)
        super().update(other)