Feature/oop support

dpath/__init__.py

@@ -18,6 +18,7 @@
     "Path",
     "Hints",
     "Creator",
+    "DDict",
 ]
 
 from collections.abc import MutableMapping, MutableSequence
@@ -26,6 +27,8 @@
 from dpath import segments, options
 from dpath.exceptions import InvalidKeyName, PathNotFound
 from dpath.types import MergeType, PathSegment, Creator, Filter, Glob, Path, Hints
+from dpath.ddict import DDict
+
 
 _DEFAULT_SENTINEL = object()
 

dpath/ddict.py

@@ -0,0 +1,135 @@
+from copy import deepcopy
+from typing import Any, MutableMapping
+
+from dpath import Creator
+from dpath.types import MergeType, Filter, Glob
+
+_DEFAULT_SENTINEL: Any = object()
+
+
+class DDict(dict):
+    """
+    Glob aware dict
+    """
+
+    def __init__(self, data: MutableMapping, __separator="/", __creator: Creator = None, **kwargs):
+        super().__init__()
+        super().update(data, **kwargs)
+
+        self.separator = __separator
+        self.creator = __creator
+
+        self.recursive_items = True
+
+    def __getitem__(self, item):
+        return self.get(item)
+
+    def __contains__(self, item):
+        return len(self.search(item)) > 0
+
+    def __setitem__(self, glob, value):
+        from dpath import new
+
+        # Prevent infinite recursion and other issues
+        temp = dict(self)
+
+        new(temp, glob, value, separator=self.separator, creator=self.creator)
+
+        self.clear()
+        self.update(temp)
+
+    def __delitem__(self, glob: Glob, afilter: Filter = None):
+        from dpath import delete
+
+        temp = dict(self)
+
+        delete(temp, glob, separator=self.separator, afilter=afilter)
+
+        self.clear()
+        self.update(temp)
+
+    def __or__(self, other):
+        from dpath import merge
+
+        copy = deepcopy(self)
+        return merge(copy, other, self.separator)
+
+    def __ior__(self, other):
+        return self.merge(other)
+
+    def __len__(self):
+        return sum(1 for _ in self.keys())
+
+    def __repr__(self):
+        return f"{type(self).__name__}({super().__repr__()})"
+
+    def get(self, glob: Glob, default=_DEFAULT_SENTINEL) -> Any:
+        """
+        Same as dict.get but accepts glob aware keys.
+        """
+        from dpath import get
+
+        if default is _DEFAULT_SENTINEL:
+            # Let util.get handle default value
+            return get(self, glob, separator=self.separator)
+        else:
+            # Default value was passed
+            return get(self, glob, separator=self.separator, default=default)
+
+    def setdefault(self, glob: Glob, __default=_DEFAULT_SENTINEL):
+        if glob in self:
+            return self[glob]
+
+        self[glob] = None if __default == _DEFAULT_SENTINEL else __default
+        return self[glob]
+
+    def pop(self, glob: Glob):
+        results = self.search(glob)
+        del self[glob]
+        return results
+
+    def search(self, glob: Glob, yielded=False, afilter: Filter = None, dirs=True):
+        from dpath import search
+
+        return search(self, glob, yielded=yielded, separator=self.separator, afilter=afilter, dirs=dirs)
+
+    def merge(self, src: MutableMapping, afilter: Filter = None, flags=MergeType.ADDITIVE):
+        """
+        Performs in-place merge with another dict.
+        """
+        from dpath import merge
+
+        result = merge(self, src, separator=self.separator, afilter=afilter, flags=flags)
+
+        self.update(result)
+
+        return self
+
+    def keys(self):
+        from dpath.segments import walk
+
+        if not self.recursive_items:
+            yield from dict(self).keys()
+            return
+
+        for path, _ in walk(self):
+            yield self.separator.join((str(segment) for segment in path))
+
+    def values(self):
+        from dpath.segments import walk
+
+        d = self
+        if not self.recursive_items:
+            d = dict(self)
+
+        for _, value in walk(d):
+            yield value
+
+    def walk(self):
+        """
+        Yields all possible key, value pairs.
+        """
+        from dpath.segments import walk
+
+        for path, value in walk(self):
+            yield self.separator.join((str(segment) for segment in path)), value

dpath/version.py

@@ -1 +1 @@
-VERSION = "2.1.2"
+VERSION = "2.2.0"

tests/test_oop.py

@@ -0,0 +1,201 @@
+from copy import deepcopy
+
+from dpath import DDict
+
+
+def test_oop_getitem():
+    d = DDict({
+        "a": 1,
+        "b": [12, 23, 34],
+    })
+
+    assert d["a"] == 1
+    assert d["b/0"] == 12
+    assert d["b/-1"] == 34
+
+
+def test_oop_setitem():
+    d = DDict({
+        "a": 1,
+        "b": [12, 23, 34],
+    })
+
+    d["b/5"] = 1
+    assert d["b"][5] == 1
+
+    d["c"] = [54, 43, 32, 21]
+    assert d["c"] == [54, 43, 32, 21]
+
+
+def test_oop_delitem():
+    d = DDict({
+        "a": 1,
+        "b": [12, 23, 34],
+        "c": {
+            "d": {
+                "e": [56, 67]
+            }
+        }
+    })
+
+    del d["a"]
+    assert "a" not in d
+
+    del d["c/**/1"]
+    assert 67 not in d["c/d/e"]
+
+
+def test_oop_pop():
+    d = DDict({
+        "a": 1,
+        "b": [12, 23, 34],
+        "c": {
+            "d": {
+                "e": [56, 67]
+            }
+        }
+    })
+    before = deepcopy(d)
+
+    popped = d.pop("a")
+    assert popped == {"a": 1}
+
+    d = deepcopy(before)
+    popped = d.pop("b/1")
+    assert popped == {"b": [None, 23]}
+
+    d = deepcopy(before)
+    popped = d.pop("c/**/1")
+    assert popped == {
+        "c": {
+            "d": {
+                "e": [None, 67]
+            }
+        }
+    }
+
+
+def test_oop_setitem_overwrite():
+    d = DDict({
+        "a": 1,
+        "b": [12, 23, 34],
+    })
+
+    d["b"] = "abc"
+    assert d["b"] == "abc"
+
+
+def test_oop_contains():
+    d = DDict({
+        "a": 1,
+        "b": [12, 23, 34],
+        "c": {
+            "d": {
+                "e": [56, 67]
+            }
+        }
+    })
+
+    assert "a" in d
+    assert "b" in d
+    assert "b/0" in d
+    assert "c/d/e/1" in d
+
+
+def test_oop_merge():
+    d = DDict({
+        "a": 1,
+        "b": [12, 23, 34],
+        "c": {
+            "d": {
+                "e": [56, 67]
+            }
+        }
+    })
+
+    expected_after = {
+        "a": 1,
+        "b": [12, 23, 34],
+        "c": {
+            "d": {
+                "e": [56, 67]
+            }
+        },
+        "f": [54],
+    }
+
+    before = deepcopy(d)
+
+    assert d | {"f": [54]} == expected_after
+
+    assert d == before
+
+    d |= {"f": [54]}
+
+    assert d != before
+    assert d == expected_after
+
+
+def test_oop_len():
+    d = DDict({
+        "a": 1,
+        "b": [12, 23, 34],
+        "c": {
+            "d": {
+                "e": [56, 67]
+            }
+        }
+    })
+
+    assert len(d) == 10, len(d)
+
+    d.recursive_items = False
+    assert len(d) == 3, len(d)
+
+
+def test_oop_keys():
+    d = DDict({
+        "a": 1,
+        "b": [12, 23, 34],
+        "c": {
+            "d": {
+                "e": [56, 67]
+            }
+        }
+    })
+
+    assert not {
+        "a",
+        "b",
+        "c",
+        "b/0",
+        "b/1",
+        "b/2",
+        "c/d",
+        "c/d/e",
+        "c/d/e/0",
+        "c/d/e/1",
+    }.difference(set(d.keys()))
+
+
+def test_oop_setdefault():
+    d = DDict({
+        "a": 1,
+        "b": [12, 23, 34],
+        "c": {
+            "d": {
+                "e": [56, 67]
+            }
+        }
+    })
+
+    res = d.setdefault("a", 345)
+    assert res == 1
+
+    res = d.setdefault("c/4", 567)
+    assert res == 567
+    assert d["c"]["4"] == res
+
+    res = d.setdefault("b/6", 89)
+    assert res == 89
+    assert d["b"] == [12, 23, 34, None, None, None, 89]