Merge branch 'main' into doc/readme

Author: HansBug

test/tree/common/test_storage.py

@@ -4,6 +4,13 @@
 
 from treevalue.tree.common import create_storage, raw, TreeStorage, delayed_partial
 
+try:
+    _ = reversed({}.keys())
+except TypeError:
+    _reversible = False
+else:
+    _reversible = True
+
 
 # noinspection PyArgumentList,DuplicatedCode,PyTypeChecker
 @pytest.mark.unittest
@@ -501,33 +508,49 @@ def test_keys(self):
         h2 = {'x': 3, 'y': 4}
         t = create_storage({'a': 1, 'b': 2, 'c': raw(h1), 'd': h2, 'f': h2})
 
-        assert set(t.keys()) == {'a', 'b', 'c', 'd', 'f'}
-        assert set(t.get('f').keys()) == {'x', 'y'}
+        assert set(t.iter_keys()) == {'a', 'b', 'c', 'd', 'f'}
+        assert set(t.get('f').iter_keys()) == {'x', 'y'}
+
+        if _reversible:
+            assert list(t.iter_rev_keys()) == list(t.iter_keys())[::-1]
+        else:
+            with pytest.raises(TypeError):
+                t.iter_rev_keys()
 
     def test_values(self):
         h1 = {'x': 3, 'y': 4}
         t = create_storage({'a': 1, 'b': 2, 'd': h1})
 
-        assert set(t.get('d').values()) == {3, 4}
-        assert len(list(t.values())) == 3
-        assert 1 in t.values()
-        assert 2 in t.values()
+        assert set(t.get('d').iter_values()) == {3, 4}
+        assert len(list(t.iter_values())) == 3
+        assert 1 in t.iter_values()
+        assert 2 in t.iter_values()
+        if _reversible:
+            assert list(t.iter_rev_values()) == list(t.iter_values())[::-1]
+        else:
+            with pytest.raises(TypeError):
+                _ = list(t.iter_rev_values())
 
         t1 = create_storage({
             'a': delayed_partial(lambda: t.get('a')),
             'b': delayed_partial(lambda: t.get('b')),
             'd': delayed_partial(lambda: t.get('d')),
         })
-        assert set(t1.get('d').values()) == {3, 4}
-        assert len(list(t1.values())) == 3
-        assert 1 in t1.values()
-        assert 2 in t1.values()
+        assert set(t1.get('d').iter_values()) == {3, 4}
+        assert len(list(t1.iter_values())) == 3
+        assert 1 in t1.iter_values()
+        assert 2 in t1.iter_values()
+        if _reversible:
+            assert list(t1.iter_rev_values()) == list(t1.iter_values())[::-1]
+        else:
+            with pytest.raises(TypeError):
+                _ = list(t1.iter_rev_values())
 
     def test_items(self):
         h1 = {'x': 3, 'y': 4}
         t = create_storage({'a': 1, 'b': 2, 'd': raw(h1)})
 
-        for k, v in t.items():
+        for k, v in t.iter_items():
             if k == 'a':
                 assert v == 1
             elif k == 'b':
@@ -537,12 +560,18 @@ def test_items(self):
             else:
                 pytest.fail('Should not reach here.')
 
+        if _reversible:
+            assert list(t.iter_rev_items()) == list(t.iter_items())[::-1]
+        else:
+            with pytest.raises(TypeError):
+                _ = list(t.iter_rev_items())
+
         t1 = create_storage({
             'a': delayed_partial(lambda: t.get('a')),
             'b': delayed_partial(lambda: t.get('b')),
             'd': delayed_partial(lambda: t.get('d')),
         })
-        for k, v in t1.items():
+        for k, v in t1.iter_items():
             if k == 'a':
                 assert v == 1
             elif k == 'b':
@@ -552,6 +581,12 @@ def test_items(self):
             else:
                 pytest.fail('Should not reach here.')
 
+        if _reversible:
+            assert list(t1.iter_rev_values()) == list(t1.iter_values())[::-1]
+        else:
+            with pytest.raises(TypeError):
+                _ = list(t1.iter_rev_values())
+
     def test_hash(self):
         h = {}
 

test/tree/tree/test_tree.py

@@ -5,6 +5,13 @@
 
 from treevalue import raw, TreeValue, delayed
 
+try:
+    _ = reversed({}.keys())
+except TypeError:
+    _reversible = False
+else:
+    _reversible = True
+
 
 class _Container:
     def __init__(self, value):
@@ -240,12 +247,14 @@ def test_tree_value_bool(self):
         assert tv2
         assert not tv2.c
 
-    def test_tee_value_hash_equal(self):
+    def test_tree_value_hash_equal(self):
         tv1 = TreeValue({'a': 1, 'b': 2, 'c': {'x': 2, 'y': 3}})
         assert tv1 == tv1
         assert not tv1 == 2
         assert tv1 == TreeValue({'a': 1, 'b': 2, 'c': {'x': 2, 'y': 3}})
+        assert tv1 != TreeValue({'a': 1, 'b': 2, 'c': {'x': 2, 'y': 4}})
         assert tv1.c == TreeValue({'x': 2, 'y': 3})
+        assert tv1.c != TreeValue({'x': 2, 'y': 3, 'z': 4})
 
         d = {
             tv1: 1,
@@ -330,23 +339,61 @@ def test_pop(self):
 
     def test_keys(self):
         tv1 = TreeValue({'a': 1, 'b': 2, 'c': {'x': 2, 'y': 3}, 'd': raw({'x': 2, 'y': 3})})
+        assert len(tv1.keys()) == 4
         assert set(tv1.keys()) == {'a', 'b', 'c', 'd'}
+        assert 'a' in tv1.keys()
+        assert 'b' in tv1.keys()
+        assert 'c' in tv1.keys()
+        assert 'd' in tv1.keys()
+        assert 'e' not in tv1.keys()
+
+        assert repr(tv1.keys()) == "treevalue_keys(['a', 'b', 'c', 'd'])"
+        if _reversible:
+            assert list(reversed(tv1.keys())) == list(tv1.keys())[::-1]
+        else:
+            with pytest.raises(TypeError):
+                reversed(tv1.keys())
 
     def test_values(self):
         tv1 = TreeValue({'a': 1, 'b': 2, 'c': {'x': 2, 'y': 3}})
+        assert len(tv1.values()) == 3
         assert set(tv1.c.values()) == {2, 3}
-        assert len(list(tv1.values())) == 3
         assert 1 in tv1.values()
         assert 2 in tv1.values()
+        assert 3 not in tv1.values()
+        assert TreeValue({'x': 2, 'y': 3}) in tv1.values()
+        assert TreeValue({'x': 2, 'y': 4}) not in tv1.values()
+
+        assert repr(TreeValue({'a': 1, 'b': 2}).values()) == 'treevalue_values([1, 2])'
+        if _reversible:
+            assert list(reversed(tv1.values())) == list(tv1.values())[::-1]
+        else:
+            with pytest.raises(TypeError):
+                reversed(tv1.values())
 
     def test_items(self):
         tv1 = TreeValue({'a': 1, 'b': 2, 'c': {'x': 2, 'y': 3}, 'd': raw({'x': 2, 'y': 3})})
+        assert len(tv1.items()) == 4
         assert sorted(tv1.items()) == [
             ('a', 1),
             ('b', 2),
             ('c', TreeValue({'x': 2, 'y': 3})),
             ('d', {'x': 2, 'y': 3}),
         ]
+        assert ('a', 1) in tv1.items()
+        assert ('b', 2) in tv1.items()
+        assert ('a', 2) not in tv1.items()
+        assert ('c', TreeValue({'x': 2, 'y': 3})) in tv1.items()
+        assert ('c', TreeValue({'x': 2, 'y': 4})) not in tv1.items()
+        assert ('d', {'x': 2, 'y': 3}) in tv1.items()
+        assert ('d', {'x': 2, 'y': 4}) not in tv1.items()
+
+        assert repr(TreeValue({'a': 1, 'b': 2}).items()) == "treevalue_items([('a', 1), ('b', 2)])"
+        if _reversible:
+            assert list(reversed(tv1.items())) == list(tv1.items())[::-1]
+        else:
+            with pytest.raises(TypeError):
+                reversed(tv1.items())
 
         class MyTreeValue(TreeValue):
             pass

treevalue/tree/common/storage.pyx

@@ -185,27 +185,41 @@ cdef class TreeStorage:
         cdef str k
         cdef object v
         cdef list _items = []
-        for k, v in sorted(self.items(), key=lambda x: x[0]):
+        for k, v in sorted(self.iter_items(), key=lambda x: x[0]):
             _items.append((k, v))
 
         return hash(tuple(_items))
 
-    def keys(self):
+    def iter_keys(self):
         return self.map.keys()
 
-    def values(self):
+    def iter_rev_keys(self):
+        return reversed(self.map.keys())
+
+    def iter_values(self):
         cdef str k
         cdef object v, nv
         for k, v in self.map.items():
             yield _c_undelay_data(self.map, k, v)
 
-    def items(self):
+    def iter_rev_values(self):
+        cdef str k
+        cdef object v, nv
+        for k, v in reversed(self.map.items()):
+            yield _c_undelay_data(self.map, k, v)
+
+    def iter_items(self):
         cdef str k
         cdef object v, nv
         for k, v in self.map.items():
-            v = _c_undelay_data(self.map, k, v)
+            yield k, _c_undelay_data(self.map, k, v)
+
+    def iter_rev_items(self):
+        cdef str k
+        cdef object v, nv
+        for k, v in reversed(self.map.items()):
+            yield k, _c_undelay_data(self.map, k, v)
 
-            yield k, v
 
 cpdef object create_storage(dict value):
     cdef dict _map = {}

treevalue/tree/tree/tree.pxd

@@ -6,6 +6,9 @@ from libcpp cimport bool
 from ..common.delay cimport DelayedProxy
 from ..common.storage cimport TreeStorage
 
+cdef class _CObject:
+    pass
+
 cdef class TreeValue:
     cdef readonly TreeStorage _st
     cdef readonly type _type
@@ -20,9 +23,29 @@ cdef class TreeValue:
     cpdef get(self, str key, object default= *)
     cpdef pop(self, str key, object default= *)
 
+    cpdef treevalue_keys keys(self)
+    cpdef treevalue_values values(self)
+    cpdef treevalue_items items(self)
+
 cdef str _prefix_fix(object text, object prefix)
+cdef str _title_repr(TreeStorage st, object type_)
 cdef object _build_tree(TreeStorage st, object type_, str prefix, dict id_pool, tuple path)
 
+# noinspection PyPep8Naming
+cdef class treevalue_keys(_CObject):
+    cdef readonly TreeStorage _st
+    cdef readonly type _type
+
+# noinspection PyPep8Naming
+cdef class treevalue_values(_CObject):
+    cdef readonly TreeStorage _st
+    cdef readonly type _type
+
+# noinspection PyPep8Naming
+cdef class treevalue_items(_CObject):
+    cdef readonly TreeStorage _st
+    cdef readonly type _type
+
 cdef class DetachedDelayedProxy(DelayedProxy):
     cdef DelayedProxy proxy
     cdef readonly bool calculated