flip graph fethc result flags

5 files changed, 209 insertions, 164 deletions

diff --git a/bsfs/graph/nodes.py b/bsfs/graph/nodes.py
index 85e5fdb..9990714 100644
--- a/bsfs/graph/nodes.py
+++ b/bsfs/graph/nodes.py
@@ -277,9 +277,9 @@ class Nodes():
                 yield node, path, value
 
         # simplify by default
-        view_kwargs['node'] = view_kwargs.get('node', len(self._guids) == 1)
-        view_kwargs['path'] = view_kwargs.get('path', len(paths) == 1)
-        view_kwargs['value'] = view_kwargs.get('value', True)
+        view_kwargs['node'] = view_kwargs.get('node', len(self._guids) != 1)
+        view_kwargs['path'] = view_kwargs.get('path', len(paths) != 1)
+        view_kwargs['value'] = view_kwargs.get('value', False)
 
         # return results view
         if view == list:
diff --git a/bsfs/graph/result.py b/bsfs/graph/result.py
index 688929b..00607f4 100644
--- a/bsfs/graph/result.py
+++ b/bsfs/graph/result.py
@@ -38,11 +38,11 @@ def to_list_view(
     the respective component is omitted.
 
     """
-    if node and path:
+    if not node and not path:
         return iter(val for _, _, val in triples)
-    if node:
+    if not node:
         return iter((pred, val) for _, pred, val in triples)
-    if path:
+    if not path:
         return iter((subj, val) for subj, _, val in triples)
     return iter((subj, pred, val) for subj, pred, val in triples)
 
@@ -57,6 +57,7 @@ def to_dict_view(
         node: bool,
         path: bool,
         value: bool,
+        default: typing.Optional[typing.Any] = None,
         ) -> typing.Any:
     """Return a dict of results.
 
@@ -74,7 +75,7 @@ def to_dict_view(
 
     # FIXME: type of data can be overwritten later on (if value)
 
-    if node and path:
+    if not node and not path:
         data = set()
     elif node ^ path:
         data = defaultdict(set)
@@ -83,24 +84,24 @@ def to_dict_view(
 
     for subj, pred, val in triples:
         unique = pred in unique_paths
-        if node and path:
-            if value and unique and one_node and one_path:
+        if not node and not path:
+            if not value and unique and one_node and one_path:
                 return val
             data.add(val)
-        elif node:
+        elif not node:
             # remove node from result, group by predicate
-            if value and unique and one_node:
+            if not value and unique and one_node:
                 data[pred] = val
             else:
                 data[pred].add(val)
-        elif path:
+        elif not path:
             # remove predicate from result, group by node
-            if value and unique and one_path:
+            if not value and unique and one_path:
                 data[subj] = val
             else:
                 data[subj].add(val)
         else:
-            if value and unique:
+            if not value and unique:
                 data[subj][pred] = val
             else:
                 data[subj][pred].add(val)
@@ -108,7 +109,11 @@ def to_dict_view(
     # FIXME: Combine multiple Nodes instances into one?
 
     # convert defaultdict to ordinary dict
-    if node and path:
+    if not node and not path and not value \
+       and len(unique_paths) > 0 and one_node and one_path \
+       and len(data) == 0:
+        return default
+    if not node and not path:
         return data
     if node ^ path:
         return dict(data)
diff --git a/test/graph/test_nodes.py b/test/graph/test_nodes.py
index c07fa53..dabe794 100644
--- a/test/graph/test_nodes.py
+++ b/test/graph/test_nodes.py
@@ -417,11 +417,11 @@ class TestNodes(unittest.TestCase):
             Nodes(self.backend, self.user, self.ent_type, {'http://example.com/me/entity#4321'}): {'tag_label_4321'},
             })
         # get returns the same path that was passed
-        self.assertCountEqual(list(nodes.get((ns.bse.tag, bst.label), path=False, view=list)), [
+        self.assertCountEqual(list(nodes.get((ns.bse.tag, bst.label), path=True, view=list)), [
             (Nodes(self.backend, self.user, self.ent_type, {'http://example.com/me/entity#1234'}), (ns.bse.tag, bst.label), 'tag_label_1234'),
             (Nodes(self.backend, self.user, self.ent_type, {'http://example.com/me/entity#4321'}), (ns.bse.tag, bst.label), 'tag_label_4321'),
             ])
-        self.assertCountEqual(list(nodes.get([ns.bse.tag, bst.label], path=False, view=list)), [
+        self.assertCountEqual(list(nodes.get([ns.bse.tag, bst.label], path=True, view=list)), [
             (Nodes(self.backend, self.user, self.ent_type, {'http://example.com/me/entity#1234'}), [ns.bse.tag, bst.label], 'tag_label_1234'),
             (Nodes(self.backend, self.user, self.ent_type, {'http://example.com/me/entity#4321'}), [ns.bse.tag, bst.label], 'tag_label_4321'),
             ])
diff --git a/test/graph/test_result.py b/test/graph/test_result.py
index 89b0da1..749b8ad 100644
--- a/test/graph/test_result.py
+++ b/test/graph/test_result.py
@@ -45,149 +45,149 @@ class TestListView(unittest.TestCase):
 
     def test_copy(self):
         # iterator yields tuples
-        self.assertIsInstance(list(to_list_view([('subject', 'predicate', 'object')], node=False, path=False, value=False))[0], tuple)
+        self.assertIsInstance(list(to_list_view([('subject', 'predicate', 'object')], node=True, path=True, value=True))[0], tuple)
         # components are not changed
         class Foo(): pass
         foo = Foo()
-        self.assertListEqual(list(to_list_view([('subject', 'predicate', 'object')], node=False, path=False, value=False)),
+        self.assertListEqual(list(to_list_view([('subject', 'predicate', 'object')], node=True, path=True, value=True)),
             [('subject', 'predicate', 'object')])
-        self.assertListEqual(list(to_list_view([(foo, 'predicate', 'object')], node=False, path=False, value=False)),
+        self.assertListEqual(list(to_list_view([(foo, 'predicate', 'object')], node=True, path=True, value=True)),
             [(foo, 'predicate', 'object')])
-        self.assertListEqual(list(to_list_view([('subject', foo, 'object')], node=False, path=False, value=False)),
+        self.assertListEqual(list(to_list_view([('subject', foo, 'object')], node=True, path=True, value=True)),
             [('subject', foo, 'object')])
-        self.assertListEqual(list(to_list_view([('subject', 'predicate', foo)], node=False, path=False, value=False)),
+        self.assertListEqual(list(to_list_view([('subject', 'predicate', foo)], node=True, path=True, value=True)),
             [('subject', 'predicate', foo)])
 
     def test_agg_none(self):
-        self.assertListEqual(list(to_list_view(self.triples_111, node=False, path=False, value=False)), self.triples_111)
-        self.assertListEqual(list(to_list_view(self.triples_11U, node=False, path=False, value=False)), self.triples_11U)
-        self.assertListEqual(list(to_list_view(self.triples_1M1, node=False, path=False, value=False)), self.triples_1M1)
-        self.assertListEqual(list(to_list_view(self.triples_1MU, node=False, path=False, value=False)), self.triples_1MU)
-        self.assertListEqual(list(to_list_view(self.triples_N11, node=False, path=False, value=False)), self.triples_N11)
-        self.assertListEqual(list(to_list_view(self.triples_N1U, node=False, path=False, value=False)), self.triples_N1U)
-        self.assertListEqual(list(to_list_view(self.triples_NM1, node=False, path=False, value=False)), self.triples_NM1)
-        self.assertListEqual(list(to_list_view(self.triples_NMU, node=False, path=False, value=False)), self.triples_NMU)
+        self.assertListEqual(list(to_list_view(self.triples_111, node=True, path=True, value=True)), self.triples_111)
+        self.assertListEqual(list(to_list_view(self.triples_11U, node=True, path=True, value=True)), self.triples_11U)
+        self.assertListEqual(list(to_list_view(self.triples_1M1, node=True, path=True, value=True)), self.triples_1M1)
+        self.assertListEqual(list(to_list_view(self.triples_1MU, node=True, path=True, value=True)), self.triples_1MU)
+        self.assertListEqual(list(to_list_view(self.triples_N11, node=True, path=True, value=True)), self.triples_N11)
+        self.assertListEqual(list(to_list_view(self.triples_N1U, node=True, path=True, value=True)), self.triples_N1U)
+        self.assertListEqual(list(to_list_view(self.triples_NM1, node=True, path=True, value=True)), self.triples_NM1)
+        self.assertListEqual(list(to_list_view(self.triples_NMU, node=True, path=True, value=True)), self.triples_NMU)
 
     def test_agg_node(self):
-        self.assertListEqual(list(to_list_view(self.triples_111, node=True, path=False, value=False)),
+        self.assertListEqual(list(to_list_view(self.triples_111, node=False, path=True, value=True)),
             [(ns.bse.iso, 123)])
-        self.assertListEqual(list(to_list_view(self.triples_11U, node=True, path=False, value=False)),
+        self.assertListEqual(list(to_list_view(self.triples_11U, node=False, path=True, value=True)),
             [(ns.bse.tag, 'tag#1234'), (ns.bse.tag, 'tag#5678')])
-        self.assertListEqual(list(to_list_view(self.triples_1M1, node=True, path=False, value=False)),
+        self.assertListEqual(list(to_list_view(self.triples_1M1, node=False, path=True, value=True)),
             [(ns.bse.iso, 123), (ns.bse.t_created, '2010-01-02')])
-        self.assertListEqual(list(to_list_view(self.triples_1MU, node=True, path=False, value=False)),
+        self.assertListEqual(list(to_list_view(self.triples_1MU, node=False, path=True, value=True)),
             [(ns.bse.iso, 123), (ns.bse.tag, 'tag#1234'), (ns.bse.tag, 'tag#5678')])
-        self.assertListEqual(list(to_list_view(self.triples_N11, node=True, path=False, value=False)),
+        self.assertListEqual(list(to_list_view(self.triples_N11, node=False, path=True, value=True)),
             [(ns.bse.iso, 123), (ns.bse.iso, 321)])
-        self.assertListEqual(list(to_list_view(self.triples_N1U, node=True, path=False, value=False)),
+        self.assertListEqual(list(to_list_view(self.triples_N1U, node=False, path=True, value=True)),
             [(ns.bse.tag, 'tag#1234'), (ns.bse.tag, 'tag#5678'), (ns.bse.tag, 'tag#4321')])
-        self.assertListEqual(list(to_list_view(self.triples_NM1, node=True, path=False, value=False)),
+        self.assertListEqual(list(to_list_view(self.triples_NM1, node=False, path=True, value=True)),
             [(ns.bse.iso, 123), (ns.bse.t_created, '2010-01-02'), (ns.bse.iso, 321), (ns.bse.t_created, '2022-02-22')])
-        self.assertListEqual(list(to_list_view(self.triples_NMU, node=True, path=False, value=False)),
+        self.assertListEqual(list(to_list_view(self.triples_NMU, node=False, path=True, value=True)),
             [(ns.bse.iso, 123), (ns.bse.tag, 'tag#1234'), (ns.bse.tag, 'tag#5678'), (ns.bse.iso, 321), (ns.bse.t_created, '2022-02-22')])
 
     def test_agg_path(self):
-        self.assertListEqual(list(to_list_view(self.triples_111, node=False, path=True, value=False)),
+        self.assertListEqual(list(to_list_view(self.triples_111, node=True, path=False, value=True)),
             [('ent#1234', 123)])
-        self.assertListEqual(list(to_list_view(self.triples_11U, node=False, path=True, value=False)),
+        self.assertListEqual(list(to_list_view(self.triples_11U, node=True, path=False, value=True)),
             [('ent#1234', 'tag#1234'), ('ent#1234', 'tag#5678')])
-        self.assertListEqual(list(to_list_view(self.triples_1M1, node=False, path=True, value=False)),
+        self.assertListEqual(list(to_list_view(self.triples_1M1, node=True, path=False, value=True)),
             [('ent#1234', 123), ('ent#1234', '2010-01-02')])
-        self.assertListEqual(list(to_list_view(self.triples_1MU, node=False, path=True, value=False)),
+        self.assertListEqual(list(to_list_view(self.triples_1MU, node=True, path=False, value=True)),
             [('ent#1234', 123), ('ent#1234', 'tag#1234'), ('ent#1234', 'tag#5678')])
-        self.assertListEqual(list(to_list_view(self.triples_N11, node=False, path=True, value=False)),
+        self.assertListEqual(list(to_list_view(self.triples_N11, node=True, path=False, value=True)),
             [('ent#1234', 123), ('ent#4321', 321)])
-        self.assertListEqual(list(to_list_view(self.triples_N1U, node=False, path=True, value=False)),
+        self.assertListEqual(list(to_list_view(self.triples_N1U, node=True, path=False, value=True)),
             [('ent#1234', 'tag#1234'), ('ent#1234', 'tag#5678'), ('ent#4321', 'tag#4321')])
-        self.assertListEqual(list(to_list_view(self.triples_NM1, node=False, path=True, value=False)),
+        self.assertListEqual(list(to_list_view(self.triples_NM1, node=True, path=False, value=True)),
             [('ent#1234', 123), ('ent#1234', '2010-01-02'), ('ent#4321', 321), ('ent#4321', '2022-02-22')])
-        self.assertListEqual(list(to_list_view(self.triples_NMU, node=False, path=True, value=False)),
+        self.assertListEqual(list(to_list_view(self.triples_NMU, node=True, path=False, value=True)),
             [('ent#1234', 123), ('ent#1234', 'tag#1234'), ('ent#1234', 'tag#5678'), ('ent#4321', 321), ('ent#4321', '2022-02-22')])
 
     def test_agg_node_path(self):
-        self.assertListEqual(list(to_list_view(self.triples_111, node=True, path=True, value=False)),
+        self.assertListEqual(list(to_list_view(self.triples_111, node=False, path=False, value=True)),
             [123])
-        self.assertListEqual(list(to_list_view(self.triples_11U, node=True, path=True, value=False)),
+        self.assertListEqual(list(to_list_view(self.triples_11U, node=False, path=False, value=True)),
             ['tag#1234', 'tag#5678'])
-        self.assertListEqual(list(to_list_view(self.triples_1M1, node=True, path=True, value=False)),
+        self.assertListEqual(list(to_list_view(self.triples_1M1, node=False, path=False, value=True)),
             [123, '2010-01-02'])
-        self.assertListEqual(list(to_list_view(self.triples_1MU, node=True, path=True, value=False)),
+        self.assertListEqual(list(to_list_view(self.triples_1MU, node=False, path=False, value=True)),
             [123, 'tag#1234', 'tag#5678'])
-        self.assertListEqual(list(to_list_view(self.triples_N11, node=True, path=True, value=False)),
+        self.assertListEqual(list(to_list_view(self.triples_N11, node=False, path=False, value=True)),
             [123, 321])
-        self.assertListEqual(list(to_list_view(self.triples_N1U, node=True, path=True, value=False)),
+        self.assertListEqual(list(to_list_view(self.triples_N1U, node=False, path=False, value=True)),
             ['tag#1234', 'tag#5678', 'tag#4321'])
-        self.assertListEqual(list(to_list_view(self.triples_NM1, node=True, path=True, value=False)),
+        self.assertListEqual(list(to_list_view(self.triples_NM1, node=False, path=False, value=True)),
             [123, '2010-01-02', 321, '2022-02-22'])
-        self.assertListEqual(list(to_list_view(self.triples_NMU, node=True, path=True, value=False)),
+        self.assertListEqual(list(to_list_view(self.triples_NMU, node=False, path=False, value=True)),
             [123, 'tag#1234', 'tag#5678', 321, '2022-02-22'])
 
     def test_agg_value(self):
         # value flag has no effect
-        self.assertListEqual(list(to_list_view(self.triples_111, node=False, path=False, value=False)), self.triples_111)
-        self.assertListEqual(list(to_list_view(self.triples_11U, node=False, path=False, value=False)), self.triples_11U)
-        self.assertListEqual(list(to_list_view(self.triples_1M1, node=False, path=False, value=False)), self.triples_1M1)
-        self.assertListEqual(list(to_list_view(self.triples_1MU, node=False, path=False, value=False)), self.triples_1MU)
-        self.assertListEqual(list(to_list_view(self.triples_N11, node=False, path=False, value=False)), self.triples_N11)
-        self.assertListEqual(list(to_list_view(self.triples_N1U, node=False, path=False, value=False)), self.triples_N1U)
-        self.assertListEqual(list(to_list_view(self.triples_NM1, node=False, path=False, value=False)), self.triples_NM1)
-        self.assertListEqual(list(to_list_view(self.triples_NMU, node=False, path=False, value=False)), self.triples_NMU)
+        self.assertListEqual(list(to_list_view(self.triples_111, node=True, path=True, value=True)), self.triples_111)
+        self.assertListEqual(list(to_list_view(self.triples_11U, node=True, path=True, value=True)), self.triples_11U)
+        self.assertListEqual(list(to_list_view(self.triples_1M1, node=True, path=True, value=True)), self.triples_1M1)
+        self.assertListEqual(list(to_list_view(self.triples_1MU, node=True, path=True, value=True)), self.triples_1MU)
+        self.assertListEqual(list(to_list_view(self.triples_N11, node=True, path=True, value=True)), self.triples_N11)
+        self.assertListEqual(list(to_list_view(self.triples_N1U, node=True, path=True, value=True)), self.triples_N1U)
+        self.assertListEqual(list(to_list_view(self.triples_NM1, node=True, path=True, value=True)), self.triples_NM1)
+        self.assertListEqual(list(to_list_view(self.triples_NMU, node=True, path=True, value=True)), self.triples_NMU)
 
     def test_agg_node_value(self):
         # value flag has no effect -> same test as test_agg_node
-        self.assertListEqual(list(to_list_view(self.triples_111, node=True, path=False, value=True)),
+        self.assertListEqual(list(to_list_view(self.triples_111, node=False, path=True, value=False)),
             [(ns.bse.iso, 123)])
-        self.assertListEqual(list(to_list_view(self.triples_11U, node=True, path=False, value=True)),
+        self.assertListEqual(list(to_list_view(self.triples_11U, node=False, path=True, value=False)),
             [(ns.bse.tag, 'tag#1234'), (ns.bse.tag, 'tag#5678')])
-        self.assertListEqual(list(to_list_view(self.triples_1M1, node=True, path=False, value=True)),
+        self.assertListEqual(list(to_list_view(self.triples_1M1, node=False, path=True, value=False)),
             [(ns.bse.iso, 123), (ns.bse.t_created, '2010-01-02')])
-        self.assertListEqual(list(to_list_view(self.triples_1MU, node=True, path=False, value=True)),
+        self.assertListEqual(list(to_list_view(self.triples_1MU, node=False, path=True, value=False)),
             [(ns.bse.iso, 123), (ns.bse.tag, 'tag#1234'), (ns.bse.tag, 'tag#5678')])
-        self.assertListEqual(list(to_list_view(self.triples_N11, node=True, path=False, value=True)),
+        self.assertListEqual(list(to_list_view(self.triples_N11, node=False, path=True, value=False)),
             [(ns.bse.iso, 123), (ns.bse.iso, 321)])
-        self.assertListEqual(list(to_list_view(self.triples_N1U, node=True, path=False, value=True)),
+        self.assertListEqual(list(to_list_view(self.triples_N1U, node=False, path=True, value=False)),
             [(ns.bse.tag, 'tag#1234'), (ns.bse.tag, 'tag#5678'), (ns.bse.tag, 'tag#4321')])
-        self.assertListEqual(list(to_list_view(self.triples_NM1, node=True, path=False, value=True)),
+        self.assertListEqual(list(to_list_view(self.triples_NM1, node=False, path=True, value=False)),
             [(ns.bse.iso, 123), (ns.bse.t_created, '2010-01-02'), (ns.bse.iso, 321), (ns.bse.t_created, '2022-02-22')])
-        self.assertListEqual(list(to_list_view(self.triples_NMU, node=True, path=False, value=True)),
+        self.assertListEqual(list(to_list_view(self.triples_NMU, node=False, path=True, value=False)),
             [(ns.bse.iso, 123), (ns.bse.tag, 'tag#1234'), (ns.bse.tag, 'tag#5678'), (ns.bse.iso, 321), (ns.bse.t_created, '2022-02-22')])
 
     def test_agg_path_value(self):
         # value flag has no effect -> same test as test_agg_path
-        self.assertListEqual(list(to_list_view(self.triples_111, node=False, path=True, value=True)),
+        self.assertListEqual(list(to_list_view(self.triples_111, node=True, path=False, value=False)),
             [('ent#1234', 123)])
-        self.assertListEqual(list(to_list_view(self.triples_11U, node=False, path=True, value=True)),
+        self.assertListEqual(list(to_list_view(self.triples_11U, node=True, path=False, value=False)),
             [('ent#1234', 'tag#1234'), ('ent#1234', 'tag#5678')])
-        self.assertListEqual(list(to_list_view(self.triples_1M1, node=False, path=True, value=True)),
+        self.assertListEqual(list(to_list_view(self.triples_1M1, node=True, path=False, value=False)),
             [('ent#1234', 123), ('ent#1234', '2010-01-02')])
-        self.assertListEqual(list(to_list_view(self.triples_1MU, node=False, path=True, value=True)),
+        self.assertListEqual(list(to_list_view(self.triples_1MU, node=True, path=False, value=False)),
             [('ent#1234', 123), ('ent#1234', 'tag#1234'), ('ent#1234', 'tag#5678')])
-        self.assertListEqual(list(to_list_view(self.triples_N11, node=False, path=True, value=True)),
+        self.assertListEqual(list(to_list_view(self.triples_N11, node=True, path=False, value=False)),
             [('ent#1234', 123), ('ent#4321', 321)])
-        self.assertListEqual(list(to_list_view(self.triples_N1U, node=False, path=True, value=True)),
+        self.assertListEqual(list(to_list_view(self.triples_N1U, node=True, path=False, value=False)),
             [('ent#1234', 'tag#1234'), ('ent#1234', 'tag#5678'), ('ent#4321', 'tag#4321')])
-        self.assertListEqual(list(to_list_view(self.triples_NM1, node=False, path=True, value=True)),
+        self.assertListEqual(list(to_list_view(self.triples_NM1, node=True, path=False, value=False)),
             [('ent#1234', 123), ('ent#1234', '2010-01-02'), ('ent#4321', 321), ('ent#4321', '2022-02-22')])
-        self.assertListEqual(list(to_list_view(self.triples_NMU, node=False, path=True, value=True)),
+        self.assertListEqual(list(to_list_view(self.triples_NMU, node=True, path=False, value=False)),
             [('ent#1234', 123), ('ent#1234', 'tag#1234'), ('ent#1234', 'tag#5678'), ('ent#4321', 321), ('ent#4321', '2022-02-22')])
 
     def test_agg_all(self):
         # value flag has no effect -> same test as test_agg_node_path
-        self.assertListEqual(list(to_list_view(self.triples_111, node=True, path=True, value=True)),
+        self.assertListEqual(list(to_list_view(self.triples_111, node=False, path=False, value=False)),
             [123])
-        self.assertListEqual(list(to_list_view(self.triples_11U, node=True, path=True, value=True)),
+        self.assertListEqual(list(to_list_view(self.triples_11U, node=False, path=False, value=False)),
             ['tag#1234', 'tag#5678'])
-        self.assertListEqual(list(to_list_view(self.triples_1M1, node=True, path=True, value=True)),
+        self.assertListEqual(list(to_list_view(self.triples_1M1, node=False, path=False, value=False)),
             [123, '2010-01-02'])
-        self.assertListEqual(list(to_list_view(self.triples_1MU, node=True, path=True, value=True)),
+        self.assertListEqual(list(to_list_view(self.triples_1MU, node=False, path=False, value=False)),
             [123, 'tag#1234', 'tag#5678'])
-        self.assertListEqual(list(to_list_view(self.triples_N11, node=True, path=True, value=True)),
+        self.assertListEqual(list(to_list_view(self.triples_N11, node=False, path=False, value=False)),
             [123, 321])
-        self.assertListEqual(list(to_list_view(self.triples_N1U, node=True, path=True, value=True)),
+        self.assertListEqual(list(to_list_view(self.triples_N1U, node=False, path=False, value=False)),
             ['tag#1234', 'tag#5678', 'tag#4321'])
-        self.assertListEqual(list(to_list_view(self.triples_NM1, node=True, path=True, value=True)),
+        self.assertListEqual(list(to_list_view(self.triples_NM1, node=False, path=False, value=False)),
             [123, '2010-01-02', 321, '2022-02-22'])
-        self.assertListEqual(list(to_list_view(self.triples_NMU, node=True, path=True, value=True)),
+        self.assertListEqual(list(to_list_view(self.triples_NMU, node=False, path=False, value=False)),
             [123, 'tag#1234', 'tag#5678', 321, '2022-02-22'])
 
 
@@ -219,170 +219,210 @@ class TestDictView(unittest.TestCase):
 
     def test_errounous_call(self):
         # return set instead of value
-        self.assertSetEqual(to_dict_view(self.triples_111, one_node=False, one_path=True,  unique_paths=self.unique_paths, node=True, path=True, value=True),
+        self.assertSetEqual(to_dict_view(self.triples_111, one_node=False, one_path=True,  unique_paths=self.unique_paths, node=False, path=False, value=False),
             {123})
-        self.assertSetEqual(to_dict_view(self.triples_111, one_node=True,  one_path=False, unique_paths=self.unique_paths, node=True, path=True, value=True),
+        self.assertSetEqual(to_dict_view(self.triples_111, one_node=True,  one_path=False, unique_paths=self.unique_paths, node=False, path=False, value=False),
             {123})
         # one_node mismatch: return set of values instead of value
-        self.assertDictEqual(to_dict_view(self.triples_111, one_node=False, one_path=True, unique_paths=self.unique_paths, node=True, path=False, value=True),
+        self.assertDictEqual(to_dict_view(self.triples_111, one_node=False, one_path=True, unique_paths=self.unique_paths, node=False, path=True, value=False),
             {ns.bse.iso: {123}})
         # one_path mismatch: return set of values instead of value
-        self.assertDictEqual(to_dict_view(self.triples_111, one_node=True, one_path=False, unique_paths=self.unique_paths, node=False, path=True, value=True),
+        self.assertDictEqual(to_dict_view(self.triples_111, one_node=True, one_path=False, unique_paths=self.unique_paths, node=True, path=False, value=False),
             {'ent#1234': {123}})
         # unique_paths mismatch: return set of values instead of value
-        self.assertSetEqual(to_dict_view(self.triples_111, one_node=True, one_path=False, unique_paths={}, node=True, path=True, value=True),
+        self.assertSetEqual(to_dict_view(self.triples_111, one_node=True, one_path=False, unique_paths={}, node=False, path=False, value=False),
             {123})
-        self.assertDictEqual(to_dict_view(self.triples_111, one_node=True, one_path=False, unique_paths={}, node=True, path=False, value=True),
+        self.assertDictEqual(to_dict_view(self.triples_111, one_node=True, one_path=False, unique_paths={}, node=False, path=True, value=False),
             {ns.bse.iso: {123}})
-        self.assertDictEqual(to_dict_view(self.triples_111, one_node=True, one_path=False, unique_paths={}, node=False, path=True, value=True),
+        self.assertDictEqual(to_dict_view(self.triples_111, one_node=True, one_path=False, unique_paths={}, node=True, path=False, value=False),
             {'ent#1234': {123}})
-        self.assertDictEqual(to_dict_view(self.triples_111, one_node=True, one_path=False, unique_paths={}, node=False, path=False, value=True),
+        self.assertDictEqual(to_dict_view(self.triples_111, one_node=True, one_path=False, unique_paths={}, node=True, path=True, value=False),
             {'ent#1234': {ns.bse.iso: {123}}})
 
     def test_agg_none(self):
-        self.assertDictEqual(to_dict_view(self.triples_111, one_node=True,  one_path=True,  unique_paths=self.unique_paths, node=False, path=False, value=False),
+        self.assertDictEqual(to_dict_view(self.triples_111, one_node=True,  one_path=True,  unique_paths=self.unique_paths, node=True, path=True, value=True),
             {'ent#1234': {ns.bse.iso: {123}}})
-        self.assertDictEqual(to_dict_view(self.triples_11U, one_node=True,  one_path=True,  unique_paths=self.unique_paths, node=False, path=False, value=False),
+        self.assertDictEqual(to_dict_view(self.triples_11U, one_node=True,  one_path=True,  unique_paths=self.unique_paths, node=True, path=True, value=True),
             {'ent#1234': {ns.bse.tag: {'tag#1234', 'tag#5678'}}})
-        self.assertDictEqual(to_dict_view(self.triples_1M1, one_node=True,  one_path=False, unique_paths=self.unique_paths, node=False, path=False, value=False),
+        self.assertDictEqual(to_dict_view(self.triples_1M1, one_node=True,  one_path=False, unique_paths=self.unique_paths, node=True, path=True, value=True),
             {'ent#1234': {ns.bse.iso: {123}, ns.bse.t_created: {'2010-01-02'}}})
-        self.assertDictEqual(to_dict_view(self.triples_1MU, one_node=True,  one_path=False, unique_paths=self.unique_paths, node=False, path=False, value=False),
+        self.assertDictEqual(to_dict_view(self.triples_1MU, one_node=True,  one_path=False, unique_paths=self.unique_paths, node=True, path=True, value=True),
             {'ent#1234': {ns.bse.iso: {123}, ns.bse.tag: {'tag#1234', 'tag#5678'}}})
-        self.assertDictEqual(to_dict_view(self.triples_N11, one_node=False, one_path=True,  unique_paths=self.unique_paths, node=False, path=False, value=False),
+        self.assertDictEqual(to_dict_view(self.triples_N11, one_node=False, one_path=True,  unique_paths=self.unique_paths, node=True, path=True, value=True),
             {'ent#1234': {ns.bse.iso: {123}}, 'ent#4321': {ns.bse.iso: {321}}})
-        self.assertDictEqual(to_dict_view(self.triples_N1U, one_node=False, one_path=True,  unique_paths=self.unique_paths, node=False, path=False, value=False),
+        self.assertDictEqual(to_dict_view(self.triples_N1U, one_node=False, one_path=True,  unique_paths=self.unique_paths, node=True, path=True, value=True),
             {'ent#1234': {ns.bse.tag: {'tag#1234', 'tag#5678'}}, 'ent#4321': {ns.bse.tag: {'tag#4321'}}})
-        self.assertDictEqual(to_dict_view(self.triples_NM1, one_node=False, one_path=False, unique_paths=self.unique_paths, node=False, path=False, value=False),
+        self.assertDictEqual(to_dict_view(self.triples_NM1, one_node=False, one_path=False, unique_paths=self.unique_paths, node=True, path=True, value=True),
             {'ent#1234': {ns.bse.iso: {123}, ns.bse.t_created: {'2010-01-02'}}, 'ent#4321': {ns.bse.iso: {321}, ns.bse.t_created: {'2022-02-22'}}})
-        self.assertDictEqual(to_dict_view(self.triples_NMU, one_node=False, one_path=False, unique_paths=self.unique_paths, node=False, path=False, value=False),
+        self.assertDictEqual(to_dict_view(self.triples_NMU, one_node=False, one_path=False, unique_paths=self.unique_paths, node=True, path=True, value=True),
             {'ent#1234': {ns.bse.iso: {123}, ns.bse.tag: {'tag#1234', 'tag#5678'}}, 'ent#4321': {ns.bse.iso: {321}, ns.bse.t_created: {'2022-02-22'}}})
+        # empty
+        self.assertDictEqual(to_dict_view([], one_node=True,  one_path=True,  unique_paths=self.unique_paths, node=True, path=True, value=True), {})
+        self.assertDictEqual(to_dict_view([], one_node=True,  one_path=False, unique_paths=self.unique_paths, node=True, path=True, value=True), {})
+        self.assertDictEqual(to_dict_view([], one_node=False, one_path=True,  unique_paths=self.unique_paths, node=True, path=True, value=True), {})
+        self.assertDictEqual(to_dict_view([], one_node=False, one_path=False, unique_paths=self.unique_paths, node=True, path=True, value=True), {})
 
     def test_agg_node(self):
-        self.assertDictEqual(to_dict_view(self.triples_111, one_node=True,  one_path=True,  unique_paths=self.unique_paths, node=True, path=False, value=False),
+        self.assertDictEqual(to_dict_view(self.triples_111, one_node=True,  one_path=True,  unique_paths=self.unique_paths, node=False, path=True, value=True),
             {ns.bse.iso: {123}})
-        self.assertDictEqual(to_dict_view(self.triples_11U, one_node=True,  one_path=True,  unique_paths=self.unique_paths, node=True, path=False, value=False),
+        self.assertDictEqual(to_dict_view(self.triples_11U, one_node=True,  one_path=True,  unique_paths=self.unique_paths, node=False, path=True, value=True),
             {ns.bse.tag: {'tag#1234', 'tag#5678'}})
-        self.assertDictEqual(to_dict_view(self.triples_1M1, one_node=True,  one_path=False, unique_paths=self.unique_paths, node=True, path=False, value=False),
+        self.assertDictEqual(to_dict_view(self.triples_1M1, one_node=True,  one_path=False, unique_paths=self.unique_paths, node=False, path=True, value=True),
             {ns.bse.iso: {123}, ns.bse.t_created: {'2010-01-02'}})
-        self.assertDictEqual(to_dict_view(self.triples_1MU, one_node=True,  one_path=False, unique_paths=self.unique_paths, node=True, path=False, value=False),
+        self.assertDictEqual(to_dict_view(self.triples_1MU, one_node=True,  one_path=False, unique_paths=self.unique_paths, node=False, path=True, value=True),
             {ns.bse.iso: {123}, ns.bse.tag: {'tag#1234', 'tag#5678'}})
-        self.assertDictEqual(to_dict_view(self.triples_N11, one_node=False, one_path=True,  unique_paths=self.unique_paths, node=True, path=False, value=False),
+        self.assertDictEqual(to_dict_view(self.triples_N11, one_node=False, one_path=True,  unique_paths=self.unique_paths, node=False, path=True, value=True),
             {ns.bse.iso: {123, 321}})
-        self.assertDictEqual(to_dict_view(self.triples_N1U, one_node=False, one_path=True,  unique_paths=self.unique_paths, node=True, path=False, value=False),
+        self.assertDictEqual(to_dict_view(self.triples_N1U, one_node=False, one_path=True,  unique_paths=self.unique_paths, node=False, path=True, value=True),
             {ns.bse.tag: {'tag#1234', 'tag#5678', 'tag#4321'}})
-        self.assertDictEqual(to_dict_view(self.triples_NM1, one_node=False, one_path=False, unique_paths=self.unique_paths, node=True, path=False, value=False),
+        self.assertDictEqual(to_dict_view(self.triples_NM1, one_node=False, one_path=False, unique_paths=self.unique_paths, node=False, path=True, value=True),
             {ns.bse.iso: {123, 321}, ns.bse.t_created: {'2010-01-02', '2022-02-22'}})
-        self.assertDictEqual(to_dict_view(self.triples_NMU, one_node=False, one_path=False, unique_paths=self.unique_paths, node=True, path=False, value=False),
+        self.assertDictEqual(to_dict_view(self.triples_NMU, one_node=False, one_path=False, unique_paths=self.unique_paths, node=False, path=True, value=True),
             {ns.bse.iso: {123, 321}, ns.bse.tag: {'tag#1234', 'tag#5678'}, ns.bse.t_created: {'2022-02-22'}})
+        # empty
+        self.assertDictEqual(to_dict_view([], one_node=True,  one_path=True,  unique_paths=self.unique_paths, node=False, path=True, value=True), {})
+        self.assertDictEqual(to_dict_view([], one_node=True,  one_path=False, unique_paths=self.unique_paths, node=False, path=True, value=True), {})
+        self.assertDictEqual(to_dict_view([], one_node=False, one_path=True,  unique_paths=self.unique_paths, node=False, path=True, value=True), {})
+        self.assertDictEqual(to_dict_view([], one_node=False, one_path=False, unique_paths=self.unique_paths, node=False, path=True, value=True), {})
 
     def test_agg_path(self):
-        self.assertDictEqual(to_dict_view(self.triples_111, one_node=True,  one_path=True,  unique_paths=self.unique_paths, node=False, path=True, value=False),
+        self.assertDictEqual(to_dict_view(self.triples_111, one_node=True,  one_path=True,  unique_paths=self.unique_paths, node=True, path=False, value=True),
             {'ent#1234': {123}})
-        self.assertDictEqual(to_dict_view(self.triples_11U, one_node=True,  one_path=True,  unique_paths=self.unique_paths, node=False, path=True, value=False),
+        self.assertDictEqual(to_dict_view(self.triples_11U, one_node=True,  one_path=True,  unique_paths=self.unique_paths, node=True, path=False, value=True),
             {'ent#1234': {'tag#1234', 'tag#5678'}})
-        self.assertDictEqual(to_dict_view(self.triples_1M1, one_node=True,  one_path=False, unique_paths=self.unique_paths, node=False, path=True, value=False),
+        self.assertDictEqual(to_dict_view(self.triples_1M1, one_node=True,  one_path=False, unique_paths=self.unique_paths, node=True, path=False, value=True),
             {'ent#1234': {123, '2010-01-02'}})
-        self.assertDictEqual(to_dict_view(self.triples_1MU, one_node=True,  one_path=False, unique_paths=self.unique_paths, node=False, path=True, value=False),
+        self.assertDictEqual(to_dict_view(self.triples_1MU, one_node=True,  one_path=False, unique_paths=self.unique_paths, node=True, path=False, value=True),
             {'ent#1234': {123, 'tag#1234', 'tag#5678'}})
-        self.assertDictEqual(to_dict_view(self.triples_N11, one_node=False, one_path=True,  unique_paths=self.unique_paths, node=False, path=True, value=False),
+        self.assertDictEqual(to_dict_view(self.triples_N11, one_node=False, one_path=True,  unique_paths=self.unique_paths, node=True, path=False, value=True),
             {'ent#1234': {123}, 'ent#4321': {321}})
-        self.assertDictEqual(to_dict_view(self.triples_N1U, one_node=False, one_path=True,  unique_paths=self.unique_paths, node=False, path=True, value=False),
+        self.assertDictEqual(to_dict_view(self.triples_N1U, one_node=False, one_path=True,  unique_paths=self.unique_paths, node=True, path=False, value=True),
             {'ent#1234': {'tag#1234', 'tag#5678'}, 'ent#4321': {'tag#4321'}})
-        self.assertDictEqual(to_dict_view(self.triples_NM1, one_node=False, one_path=False, unique_paths=self.unique_paths, node=False, path=True, value=False),
+        self.assertDictEqual(to_dict_view(self.triples_NM1, one_node=False, one_path=False, unique_paths=self.unique_paths, node=True, path=False, value=True),
             {'ent#1234': {123, '2010-01-02'}, 'ent#4321': {321, '2022-02-22'}})
-        self.assertDictEqual(to_dict_view(self.triples_NMU, one_node=False, one_path=False, unique_paths=self.unique_paths, node=False, path=True, value=False),
+        self.assertDictEqual(to_dict_view(self.triples_NMU, one_node=False, one_path=False, unique_paths=self.unique_paths, node=True, path=False, value=True),
             {'ent#1234': {123, 'tag#1234', 'tag#5678'}, 'ent#4321': {321, '2022-02-22'}})
+        # empty
+        self.assertDictEqual(to_dict_view([], one_node=True,  one_path=True,  unique_paths=self.unique_paths, node=True, path=False, value=True), {})
+        self.assertDictEqual(to_dict_view([], one_node=True,  one_path=False, unique_paths=self.unique_paths, node=True, path=False, value=True), {})
+        self.assertDictEqual(to_dict_view([], one_node=False, one_path=True,  unique_paths=self.unique_paths, node=True, path=False, value=True), {})
+        self.assertDictEqual(to_dict_view([], one_node=False, one_path=False, unique_paths=self.unique_paths, node=True, path=False, value=True), {})
 
     def test_agg_node_path(self):
-        self.assertSetEqual(to_dict_view(self.triples_111, one_node=True,  one_path=True,  unique_paths=self.unique_paths, node=True, path=True, value=False),
+        self.assertSetEqual(to_dict_view(self.triples_111, one_node=True,  one_path=True,  unique_paths=self.unique_paths, node=False, path=False, value=True),
             {123})
-        self.assertSetEqual(to_dict_view(self.triples_11U, one_node=True,  one_path=True,  unique_paths=self.unique_paths, node=True, path=True, value=False),
+        self.assertSetEqual(to_dict_view(self.triples_11U, one_node=True,  one_path=True,  unique_paths=self.unique_paths, node=False, path=False, value=True),
             {'tag#1234', 'tag#5678'})
-        self.assertSetEqual(to_dict_view(self.triples_1M1, one_node=True,  one_path=False, unique_paths=self.unique_paths, node=True, path=True, value=False),
+        self.assertSetEqual(to_dict_view(self.triples_1M1, one_node=True,  one_path=False, unique_paths=self.unique_paths, node=False, path=False, value=True),
             {123, '2010-01-02'})
-        self.assertSetEqual(to_dict_view(self.triples_1MU, one_node=True,  one_path=False, unique_paths=self.unique_paths, node=True, path=True, value=False),
+        self.assertSetEqual(to_dict_view(self.triples_1MU, one_node=True,  one_path=False, unique_paths=self.unique_paths, node=False, path=False, value=True),
             {123, 'tag#1234', 'tag#5678'})
-        self.assertSetEqual(to_dict_view(self.triples_N11, one_node=False, one_path=True,  unique_paths=self.unique_paths, node=True, path=True, value=False),
+        self.assertSetEqual(to_dict_view(self.triples_N11, one_node=False, one_path=True,  unique_paths=self.unique_paths, node=False, path=False, value=True),
             {123, 321})
-        self.assertSetEqual(to_dict_view(self.triples_N1U, one_node=False, one_path=True,  unique_paths=self.unique_paths, node=True, path=True, value=False),
+        self.assertSetEqual(to_dict_view(self.triples_N1U, one_node=False, one_path=True,  unique_paths=self.unique_paths, node=False, path=False, value=True),
             {'tag#1234', 'tag#5678', 'tag#4321'})
-        self.assertSetEqual(to_dict_view(self.triples_NM1, one_node=False, one_path=False, unique_paths=self.unique_paths, node=True, path=True, value=False),
+        self.assertSetEqual(to_dict_view(self.triples_NM1, one_node=False, one_path=False, unique_paths=self.unique_paths, node=False, path=False, value=True),
             {123, '2010-01-02', 321, '2022-02-22'})
-        self.assertSetEqual(to_dict_view(self.triples_NMU, one_node=False, one_path=False, unique_paths=self.unique_paths, node=True, path=True, value=False),
+        self.assertSetEqual(to_dict_view(self.triples_NMU, one_node=False, one_path=False, unique_paths=self.unique_paths, node=False, path=False, value=True),
             {123, 'tag#1234', 'tag#5678', 321, '2022-02-22'})
+        # empty
+        self.assertSetEqual(to_dict_view([], one_node=True,  one_path=True,  unique_paths=self.unique_paths, node=False, path=False, value=True), set())
+        self.assertSetEqual(to_dict_view([], one_node=True,  one_path=False, unique_paths=self.unique_paths, node=False, path=False, value=True), set())
+        self.assertSetEqual(to_dict_view([], one_node=False, one_path=True,  unique_paths=self.unique_paths, node=False, path=False, value=True), set())
+        self.assertSetEqual(to_dict_view([], one_node=False, one_path=False, unique_paths=self.unique_paths, node=False, path=False, value=True), set())
 
     def test_agg_value(self):
-        self.assertDictEqual(to_dict_view(self.triples_111, one_node=True,  one_path=True,  unique_paths=self.unique_paths, node=False, path=False, value=True),
+        self.assertDictEqual(to_dict_view(self.triples_111, one_node=True,  one_path=True,  unique_paths=self.unique_paths, node=True, path=True, value=False),
             {'ent#1234': {ns.bse.iso: 123}})
-        self.assertDictEqual(to_dict_view(self.triples_11U, one_node=True,  one_path=True,  unique_paths=self.unique_paths, node=False, path=False, value=True),
+        self.assertDictEqual(to_dict_view(self.triples_11U, one_node=True,  one_path=True,  unique_paths=self.unique_paths, node=True, path=True, value=False),
             {'ent#1234': {ns.bse.tag: {'tag#1234', 'tag#5678'}}})
-        self.assertDictEqual(to_dict_view(self.triples_1M1, one_node=True,  one_path=False, unique_paths=self.unique_paths, node=False, path=False, value=True),
+        self.assertDictEqual(to_dict_view(self.triples_1M1, one_node=True,  one_path=False, unique_paths=self.unique_paths, node=True, path=True, value=False),
             {'ent#1234': {ns.bse.iso: 123, ns.bse.t_created: '2010-01-02'}})
-        self.assertDictEqual(to_dict_view(self.triples_1MU, one_node=True,  one_path=False, unique_paths=self.unique_paths, node=False, path=False, value=True),
+        self.assertDictEqual(to_dict_view(self.triples_1MU, one_node=True,  one_path=False, unique_paths=self.unique_paths, node=True, path=True, value=False),
             {'ent#1234': {ns.bse.iso: 123, ns.bse.tag: {'tag#1234', 'tag#5678'}}})
-        self.assertDictEqual(to_dict_view(self.triples_N11, one_node=False, one_path=True,  unique_paths=self.unique_paths, node=False, path=False, value=True),
+        self.assertDictEqual(to_dict_view(self.triples_N11, one_node=False, one_path=True,  unique_paths=self.unique_paths, node=True, path=True, value=False),
             {'ent#1234': {ns.bse.iso: 123}, 'ent#4321': {ns.bse.iso: 321}})
-        self.assertDictEqual(to_dict_view(self.triples_N1U, one_node=False, one_path=True,  unique_paths=self.unique_paths, node=False, path=False, value=True),
+        self.assertDictEqual(to_dict_view(self.triples_N1U, one_node=False, one_path=True,  unique_paths=self.unique_paths, node=True, path=True, value=False),
             {'ent#1234': {ns.bse.tag: {'tag#1234', 'tag#5678'}}, 'ent#4321': {ns.bse.tag: {'tag#4321'}}})
-        self.assertDictEqual(to_dict_view(self.triples_NM1, one_node=False, one_path=False, unique_paths=self.unique_paths, node=False, path=False, value=True),
+        self.assertDictEqual(to_dict_view(self.triples_NM1, one_node=False, one_path=False, unique_paths=self.unique_paths, node=True, path=True, value=False),
             {'ent#1234': {ns.bse.iso: 123, ns.bse.t_created: '2010-01-02'}, 'ent#4321': {ns.bse.iso: 321, ns.bse.t_created: '2022-02-22'}})
-        self.assertDictEqual(to_dict_view(self.triples_NMU, one_node=False, one_path=False, unique_paths=self.unique_paths, node=False, path=False, value=True),
+        self.assertDictEqual(to_dict_view(self.triples_NMU, one_node=False, one_path=False, unique_paths=self.unique_paths, node=True, path=True, value=False),
             {'ent#1234': {ns.bse.iso: 123, ns.bse.tag: {'tag#1234', 'tag#5678'}}, 'ent#4321': {ns.bse.iso: 321, ns.bse.t_created: '2022-02-22'}})
+        # empty
+        self.assertDictEqual(to_dict_view([], one_node=True,  one_path=True,  unique_paths=self.unique_paths, node=True, path=True, value=False), {})
+        self.assertDictEqual(to_dict_view([], one_node=True,  one_path=False, unique_paths=self.unique_paths, node=True, path=True, value=False), {})
+        self.assertDictEqual(to_dict_view([], one_node=False, one_path=True,  unique_paths=self.unique_paths, node=True, path=True, value=False), {})
+        self.assertDictEqual(to_dict_view([], one_node=False, one_path=False, unique_paths=self.unique_paths, node=True, path=True, value=False), {})
 
     def test_agg_node_value(self):
-        self.assertDictEqual(to_dict_view(self.triples_111, one_node=True,  one_path=True,  unique_paths=self.unique_paths, node=True, path=False, value=True),
+        self.assertDictEqual(to_dict_view(self.triples_111, one_node=True,  one_path=True,  unique_paths=self.unique_paths, node=False, path=True, value=False),
             {ns.bse.iso: 123})
-        self.assertDictEqual(to_dict_view(self.triples_11U, one_node=True,  one_path=True,  unique_paths=self.unique_paths, node=True, path=False, value=True),
+        self.assertDictEqual(to_dict_view(self.triples_11U, one_node=True,  one_path=True,  unique_paths=self.unique_paths, node=False, path=True, value=False),
             {ns.bse.tag: {'tag#1234', 'tag#5678'}})
-        self.assertDictEqual(to_dict_view(self.triples_1M1, one_node=True,  one_path=False, unique_paths=self.unique_paths, node=True, path=False, value=True),
+        self.assertDictEqual(to_dict_view(self.triples_1M1, one_node=True,  one_path=False, unique_paths=self.unique_paths, node=False, path=True, value=False),
             {ns.bse.iso: 123, ns.bse.t_created: '2010-01-02'})
-        self.assertDictEqual(to_dict_view(self.triples_1MU, one_node=True,  one_path=False, unique_paths=self.unique_paths, node=True, path=False, value=True),
+        self.assertDictEqual(to_dict_view(self.triples_1MU, one_node=True,  one_path=False, unique_paths=self.unique_paths, node=False, path=True, value=False),
             {ns.bse.iso: 123, ns.bse.tag: {'tag#1234', 'tag#5678'}})
-        self.assertDictEqual(to_dict_view(self.triples_N11, one_node=False, one_path=True,  unique_paths=self.unique_paths, node=True, path=False, value=True),
+        self.assertDictEqual(to_dict_view(self.triples_N11, one_node=False, one_path=True,  unique_paths=self.unique_paths, node=False, path=True, value=False),
             {ns.bse.iso: {123, 321}})
-        self.assertDictEqual(to_dict_view(self.triples_N1U, one_node=False, one_path=True,  unique_paths=self.unique_paths, node=True, path=False, value=True),
+        self.assertDictEqual(to_dict_view(self.triples_N1U, one_node=False, one_path=True,  unique_paths=self.unique_paths, node=False, path=True, value=False),
             {ns.bse.tag: {'tag#1234', 'tag#5678', 'tag#4321'}})
-        self.assertDictEqual(to_dict_view(self.triples_NM1, one_node=False, one_path=False, unique_paths=self.unique_paths, node=True, path=False, value=True),
+        self.assertDictEqual(to_dict_view(self.triples_NM1, one_node=False, one_path=False, unique_paths=self.unique_paths, node=False, path=True, value=False),
             {ns.bse.iso: {123, 321}, ns.bse.t_created: {'2010-01-02', '2022-02-22'}})
-        self.assertDictEqual(to_dict_view(self.triples_NMU, one_node=False, one_path=False, unique_paths=self.unique_paths, node=True, path=False, value=True),
+        self.assertDictEqual(to_dict_view(self.triples_NMU, one_node=False, one_path=False, unique_paths=self.unique_paths, node=False, path=True, value=False),
             {ns.bse.iso: {123, 321}, ns.bse.tag: {'tag#1234', 'tag#5678'}, ns.bse.t_created: {'2022-02-22'}})
+        # empty
+        self.assertDictEqual(to_dict_view([], one_node=True,  one_path=True,  unique_paths=self.unique_paths, node=False, path=True, value=False), {})
+        self.assertDictEqual(to_dict_view([], one_node=True,  one_path=False, unique_paths=self.unique_paths, node=False, path=True, value=False), {})
+        self.assertDictEqual(to_dict_view([], one_node=False, one_path=True,  unique_paths=self.unique_paths, node=False, path=True, value=False), {})
+        self.assertDictEqual(to_dict_view([], one_node=False, one_path=False, unique_paths=self.unique_paths, node=False, path=True, value=False), {})
 
     def test_agg_path_value(self):
-        self.assertDictEqual(to_dict_view(self.triples_111, one_node=True,  one_path=True,  unique_paths=self.unique_paths, node=False, path=True, value=True),
+        self.assertDictEqual(to_dict_view(self.triples_111, one_node=True,  one_path=True,  unique_paths=self.unique_paths, node=True, path=False, value=False),
             {'ent#1234': 123})
-        self.assertDictEqual(to_dict_view(self.triples_11U, one_node=True,  one_path=True,  unique_paths=self.unique_paths, node=False, path=True, value=True),
+        self.assertDictEqual(to_dict_view(self.triples_11U, one_node=True,  one_path=True,  unique_paths=self.unique_paths, node=True, path=False, value=False),
             {'ent#1234': {'tag#1234', 'tag#5678'}})
-        self.assertDictEqual(to_dict_view(self.triples_1M1, one_node=True,  one_path=False, unique_paths=self.unique_paths, node=False, path=True, value=True),
+        self.assertDictEqual(to_dict_view(self.triples_1M1, one_node=True,  one_path=False, unique_paths=self.unique_paths, node=True, path=False, value=False),
             {'ent#1234': {123, '2010-01-02'}})
-        self.assertDictEqual(to_dict_view(self.triples_1MU, one_node=True,  one_path=False, unique_paths=self.unique_paths, node=False, path=True, value=True),
+        self.assertDictEqual(to_dict_view(self.triples_1MU, one_node=True,  one_path=False, unique_paths=self.unique_paths, node=True, path=False, value=False),
             {'ent#1234': {123, 'tag#1234', 'tag#5678'}})
-        self.assertDictEqual(to_dict_view(self.triples_N11, one_node=False, one_path=True,  unique_paths=self.unique_paths, node=False, path=True, value=True),
+        self.assertDictEqual(to_dict_view(self.triples_N11, one_node=False, one_path=True,  unique_paths=self.unique_paths, node=True, path=False, value=False),
             {'ent#1234': 123, 'ent#4321': 321})
-        self.assertDictEqual(to_dict_view(self.triples_N1U, one_node=False, one_path=True,  unique_paths=self.unique_paths, node=False, path=True, value=True),
+        self.assertDictEqual(to_dict_view(self.triples_N1U, one_node=False, one_path=True,  unique_paths=self.unique_paths, node=True, path=False, value=False),
             {'ent#1234': {'tag#1234', 'tag#5678'}, 'ent#4321': {'tag#4321'}})
-        self.assertDictEqual(to_dict_view(self.triples_NM1, one_node=False, one_path=False, unique_paths=self.unique_paths, node=False, path=True, value=True),
+        self.assertDictEqual(to_dict_view(self.triples_NM1, one_node=False, one_path=False, unique_paths=self.unique_paths, node=True, path=False, value=False),
             {'ent#1234': {123, '2010-01-02'}, 'ent#4321': {321, '2022-02-22'}})
-        self.assertDictEqual(to_dict_view(self.triples_NMU, one_node=False, one_path=False, unique_paths=self.unique_paths, node=False, path=True, value=True),
+        self.assertDictEqual(to_dict_view(self.triples_NMU, one_node=False, one_path=False, unique_paths=self.unique_paths, node=True, path=False, value=False),
             {'ent#1234': {123, 'tag#1234', 'tag#5678'}, 'ent#4321': {321, '2022-02-22'}})
+        # empty
+        self.assertDictEqual(to_dict_view([], one_node=True,  one_path=True,  unique_paths=self.unique_paths, node=True, path=False, value=False), {})
+        self.assertDictEqual(to_dict_view([], one_node=True,  one_path=False, unique_paths=self.unique_paths, node=True, path=False, value=False), {})
+        self.assertDictEqual(to_dict_view([], one_node=False, one_path=True,  unique_paths=self.unique_paths, node=True, path=False, value=False), {})
+        self.assertDictEqual(to_dict_view([], one_node=False, one_path=False, unique_paths=self.unique_paths, node=True, path=False, value=False), {})
 
     def test_agg_all(self):
-        self.assertEqual(to_dict_view(self.triples_111, one_node=True,  one_path=True,  unique_paths=self.unique_paths, node=True, path=True, value=True),
+        self.assertEqual(to_dict_view(self.triples_111, one_node=True,  one_path=True,  unique_paths=self.unique_paths, node=False, path=False, value=False),
             123)
-        self.assertSetEqual(to_dict_view(self.triples_11U, one_node=True,  one_path=True,  unique_paths=self.unique_paths, node=True, path=True, value=True),
+        self.assertSetEqual(to_dict_view(self.triples_11U, one_node=True,  one_path=True,  unique_paths=self.unique_paths, node=False, path=False, value=False),
             {'tag#1234', 'tag#5678'})
-        self.assertSetEqual(to_dict_view(self.triples_1M1, one_node=True,  one_path=False, unique_paths=self.unique_paths, node=True, path=True, value=True),
+        self.assertSetEqual(to_dict_view(self.triples_1M1, one_node=True,  one_path=False, unique_paths=self.unique_paths, node=False, path=False, value=False),
             {123, '2010-01-02'})
-        self.assertSetEqual(to_dict_view(self.triples_1MU, one_node=True,  one_path=False, unique_paths=self.unique_paths, node=True, path=True, value=True),
+        self.assertSetEqual(to_dict_view(self.triples_1MU, one_node=True,  one_path=False, unique_paths=self.unique_paths, node=False, path=False, value=False),
             {123, 'tag#1234', 'tag#5678'})
-        self.assertSetEqual(to_dict_view(self.triples_N11, one_node=False, one_path=True,  unique_paths=self.unique_paths, node=True, path=True, value=True),
+        self.assertSetEqual(to_dict_view(self.triples_N11, one_node=False, one_path=True,  unique_paths=self.unique_paths, node=False, path=False, value=False),
             {123, 321})
-        self.assertSetEqual(to_dict_view(self.triples_N1U, one_node=False, one_path=True,  unique_paths=self.unique_paths, node=True, path=True, value=True),
+        self.assertSetEqual(to_dict_view(self.triples_N1U, one_node=False, one_path=True,  unique_paths=self.unique_paths, node=False, path=False, value=False),
             {'tag#1234', 'tag#5678', 'tag#4321'})
-        self.assertSetEqual(to_dict_view(self.triples_NM1, one_node=False, one_path=False, unique_paths=self.unique_paths, node=True, path=True, value=True),
+        self.assertSetEqual(to_dict_view(self.triples_NM1, one_node=False, one_path=False, unique_paths=self.unique_paths, node=False, path=False, value=False),
             {123, '2010-01-02', 321, '2022-02-22'})
-        self.assertSetEqual(to_dict_view(self.triples_NMU, one_node=False, one_path=False, unique_paths=self.unique_paths, node=True, path=True, value=True),
+        self.assertSetEqual(to_dict_view(self.triples_NMU, one_node=False, one_path=False, unique_paths=self.unique_paths, node=False, path=False, value=False),
             {123, 'tag#1234', 'tag#5678', 321, '2022-02-22'})
-
+        # empty
+        self.assertEqual(to_dict_view([], one_node=True,  one_path=True,  unique_paths=self.unique_paths, node=False, path=False, value=False), None)
+        self.assertSetEqual(to_dict_view([], one_node=True,  one_path=False, unique_paths=self.unique_paths, node=False, path=False, value=False), set())
+        self.assertSetEqual(to_dict_view([], one_node=False, one_path=True,  unique_paths=self.unique_paths, node=False, path=False, value=False), set())
+        self.assertSetEqual(to_dict_view([], one_node=False, one_path=False, unique_paths=self.unique_paths, node=False, path=False, value=False), set())
+        self.assertEqual(to_dict_view([], one_node=True,  one_path=True,  unique_paths=self.unique_paths, node=False, path=False, value=False, default=123), 123)
 
 ## main ##
 
diff --git a/test/graph/test_walk.py b/test/graph/test_walk.py
index 057ac85..f9dbc7a 100644
--- a/test/graph/test_walk.py
+++ b/test/graph/test_walk.py
@@ -157,12 +157,12 @@ class TestWalk(unittest.TestCase):
             self.graph.node(ns.bsfs.Entity, URI('http://example.com/me/entity#4321')): tags,
             })
         # get passes kwargs to Nodes.get
-        self.assertSetEqual(tags, walk.get(node=True))
-        self.assertSetEqual(tags, walk(node=True))
-        self.assertSetEqual(tags, set(walk.get(view=list, node=True)))
-        self.assertSetEqual(tags, set(walk(view=list, node=True)))
+        self.assertSetEqual(tags, walk.get(node=False))
+        self.assertSetEqual(tags, walk(node=False))
+        self.assertSetEqual(tags, set(walk.get(view=list, node=False)))
+        self.assertSetEqual(tags, set(walk(view=list, node=False)))
         # get returns values if need be
-        self.assertSetEqual(walk.label(node=True), {'hello', 'world'})
+        self.assertSetEqual(walk.label(node=False), {'hello', 'world'})
 
 
 ## main ##