benedict.dicts.keypath.keypath_dict

Complexity

Total Complexity

15

Size/Duplication

Total Lines	69
Duplicated Lines	0 %

Importance

Changes

0

11 Methods

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

# -*- coding: utf-8 -*-

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', '.')
        super(KeypathDict, self).__init__(*args, **kwargs)
        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(KeypathDict, self).__contains__(
            self._parse_key(key))

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

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

    def __setitem__(self, key, value):
        keypath_util.check_keys(value, self._keypath_separator)
        super(KeypathDict, self).__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(KeypathDict, self).get(
            self._parse_key(key), default)

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

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