flip graph fethc result flags

3 files changed, 189 insertions, 149 deletions

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 ##