nodes predicate walk sugar

2 files changed, 186 insertions, 1 deletions

diff --git a/test/graph/test_nodes.py b/test/graph/test_nodes.py
index a4e07ee..670df69 100644
--- a/test/graph/test_nodes.py
+++ b/test/graph/test_nodes.py
@@ -10,6 +10,7 @@ import unittest
 
 # bsie imports
 from bsfs import schema as bsc
+from bsfs.graph.walk import Walk
 from bsfs.namespace import Namespace, ns
 from bsfs.triple_store.sparql import SparqlStore
 from bsfs.utils import errors, URI
@@ -108,7 +109,8 @@ class TestNodes(unittest.TestCase):
         self.p_filesize = self.backend.schema.predicate(ns.bse.filesize)
         self.p_author = self.backend.schema.predicate(ns.bse.author)
         self.p_tag = self.backend.schema.predicate(ns.bse.tag)
-        self.p_representative = self.backend.schema.predicate(URI('http://bsfs.ai/schema/Tag#representative'))
+        self.p_representative = self.backend.schema.predicate(bst.representative)
+        self.p_label = self.backend.schema.predicate(bst.label)
         self.t_created = self.backend.schema.predicate(ns.bsm.t_created)
         self.ent_ids = {
             URI('http://example.com/me/entity#1234'),
@@ -458,6 +460,16 @@ class TestNodes(unittest.TestCase):
             Nodes(self.backend, self.user, self.ent_type, {'http://example.com/me/entity#1234'}): {'hello world'},
             })
 
+    def test_getattr(self):
+        nodes = Nodes(self.backend, self.user, self.ent_type, {'http://example.com/me/entity#1234'})
+        # can get walks to values
+        self.assertEqual(nodes.filesize, Walk(nodes, (self.p_filesize, )))
+        # can get walks to nodes
+        self.assertEqual(nodes.tag, Walk(nodes, (self.p_tag, )))
+        # can do multiple hops
+        self.assertEqual(nodes.tag.label, Walk(nodes, (self.p_tag, self.p_label)))
+        # invalid step raises an error
+        self.assertRaises(ValueError, getattr, nodes, 'foobar')
 
 ## main ##
 
diff --git a/test/graph/test_walk.py b/test/graph/test_walk.py
new file mode 100644
index 0000000..057ac85
--- /dev/null
+++ b/test/graph/test_walk.py
@@ -0,0 +1,173 @@
+"""
+
+Part of the bsfs test suite.
+A copy of the license is provided with the project.
+Author: Matthias Baumgartner, 2022
+"""
+# imports
+import unittest
+
+# bsfs imports
+from bsfs import schema as bsc
+from bsfs.graph import Graph
+from bsfs.namespace import Namespace, ns
+from bsfs.triple_store.sparql import SparqlStore
+from bsfs.utils import URI
+
+# symbol to test
+from bsfs.graph.walk import Walk
+
+## code ##
+
+bse = ns.bse
+bst = Namespace('http://bsfs.ai/schema/Tag')
+
+class TestWalk(unittest.TestCase):
+    def setUp(self):
+        # backend setup
+        self.schema = bsc.from_string('''
+            prefix rdfs: <http://www.w3.org/2000/01/rdf-schema#>
+            prefix xsd: <http://www.w3.org/2001/XMLSchema#>
+            prefix bsfs: <http://bsfs.ai/schema/>
+            prefix bse: <http://bsfs.ai/schema/Entity#>
+            prefix bst: <http://bsfs.ai/schema/Tag#>
+
+            bsfs:Entity rdfs:subClassOf bsfs:Node .
+            bsfs:Tag rdfs:subClassOf bsfs:Node .
+            bsfs:User rdfs:subClassOf bsfs:Node .
+            xsd:string rdfs:subClassOf bsfs:Literal .
+
+            bse:author rdfs:subClassOf bsfs:Predicate ;
+                rdfs:domain bsfs:Node ;
+                rdfs:range bsfs:User .
+
+            bse:tag rdfs:subClassOf bsfs:Predicate ;
+                rdfs:domain bsfs:Entity ;
+                rdfs:range bsfs:Tag .
+
+            bst:label rdfs:subClassOf bsfs:Predicate ;
+                rdfs:domain bsfs:Tag ;
+                rdfs:range xsd:string ;
+                bsfs:unique "true"^^xsd:boolean .
+
+            bst:subTagOf rdfs:subClassOf bsfs:Predicate ;
+                rdfs:domain bsfs:Tag ;
+                rdfs:range bsfs:Tag .
+
+            bst:main rdfs:subClassOf bsfs:Predicate ;
+                rdfs:domain bsfs:Tag ;
+                rdfs:range bsfs:Entity .
+
+            bst:author rdfs:subClassOf bsfs:Predicate ;
+                rdfs:domain bsfs:Tag ;
+                rdfs:range xsd:string .
+
+            ''')
+        self.backend = SparqlStore.Open()
+        self.user = URI('http://example.com/me')
+        self.graph = Graph(self.backend, self.user)
+        self.graph.migrate(self.schema)
+
+        # nodes setup
+        self.ents = self.graph.nodes(ns.bsfs.Entity, {
+            URI('http://example.com/me/entity#1234'),
+            URI('http://example.com/me/entity#4321')})
+        self.tags = self.graph.nodes(ns.bsfs.Tag, {
+            URI('http://example.com/me/tag#1234'),
+            URI('http://example.com/me/tag#4321')})
+        # add some instances
+        self.ents.set(bse.tag, self.tags)
+        self.graph.node(ns.bsfs.Tag, URI('http://example.com/me/tag#1234')).set(bst.label, 'hello')
+        self.graph.node(ns.bsfs.Tag, URI('http://example.com/me/tag#4321')).set(bst.label, 'world')
+
+    def test_essentials(self): # __eq__, __hash__, __str__, __repr__
+        p_author = self.schema.predicate(bse.author)
+        p_tag = self.schema.predicate(bse.tag)
+        p_main = self.schema.predicate(bst.main)
+        # comparison
+        self.assertEqual(Walk(self.ents, [p_tag]), Walk(self.ents, [p_tag]))
+        self.assertEqual(hash(Walk(self.ents, [p_tag])), hash(Walk(self.ents, [p_tag])))
+        # comparison respects type
+        class Foo(Walk): pass
+        self.assertNotEqual(Walk(self.ents, [p_tag]), Foo(self.ents, [p_tag]))
+        self.assertNotEqual(hash(Walk(self.ents, [p_tag])), hash(Foo(self.ents, [p_tag])))
+        # comparison respects root
+        self.assertNotEqual(Walk(self.ents, [p_author]), Walk(self.tags, [p_author]))
+        self.assertNotEqual(hash(Walk(self.ents, [p_author])), hash(Walk(self.tags, [p_author])))
+        # comparison respects path
+        self.assertNotEqual(Walk(self.tags, [p_author]), Walk(self.tags, [p_main]))
+        self.assertNotEqual(hash(Walk(self.tags, [p_author])), hash(Walk(self.tags, [p_main])))
+        # string conversion
+        self.assertEqual(str(Walk(self.ents, [p_tag, p_main])),
+            'Walk(@http://bsfs.ai/schema/Entity: http://bsfs.ai/schema/Entity#tag, http://bsfs.ai/schema/Tag#main)')
+        self.assertEqual(repr(Walk(self.ents, [p_tag, p_main])),
+            'Walk(http://bsfs.ai/schema/Entity, (http://bsfs.ai/schema/Entity#tag, http://bsfs.ai/schema/Tag#main))')
+
+    def test_tail(self):
+        self.assertEqual(Walk(self.ents, (
+            self.schema.predicate(bse.tag),
+            )).tail,
+            self.schema.node(ns.bsfs.Tag))
+        self.assertEqual(Walk(self.ents, (
+            self.schema.predicate(bse.tag),
+            self.schema.predicate(bst.main),
+            )).tail,
+            self.schema.node(ns.bsfs.Entity))
+
+    def test_step(self):
+        tag_type = self.schema.node(ns.bsfs.Tag)
+        # step returns a predicate
+        self.assertEqual(Walk.step(self.schema, tag_type, 'subTagOf'),
+            (self.schema.predicate(bst.subTagOf), ))
+        # invalid step raises an error
+        self.assertRaises(ValueError, Walk.step, self.schema, tag_type, 'foobar')
+        # ambiguous step raises an error
+        self.assertRaises(ValueError, Walk.step, self.schema, tag_type, 'author')
+
+    def test_getattr(self): # __getattr__
+        walk = Walk(self.ents, (self.schema.predicate(bse.tag), ))
+        # first step
+        self.assertEqual(walk.subTagOf, Walk(self.ents, (
+            self.schema.predicate(bse.tag),
+            self.schema.predicate(bst.subTagOf),
+            )))
+        # second step
+        self.assertEqual(walk.subTagOf.main, Walk(self.ents, (
+            self.schema.predicate(bse.tag),
+            self.schema.predicate(bst.subTagOf),
+            self.schema.predicate(bst.main),
+            )))
+        # invalid step raises an error
+        self.assertRaises(ValueError, getattr, walk, 'foobar')
+        # ambiguous step raises an error
+        self.assertRaises(ValueError, getattr, walk, 'author')
+
+    def test_get(self): # get, __call__
+        walk = Walk(self.ents, (self.schema.predicate(bse.tag), ))
+        tags = {
+            self.graph.node(ns.bsfs.Tag, URI('http://example.com/me/tag#1234')),
+            self.graph.node(ns.bsfs.Tag, URI('http://example.com/me/tag#4321'))}
+        # get returns from Nodes.get
+        self.assertDictEqual(walk.get(), {
+            self.graph.node(ns.bsfs.Entity, URI('http://example.com/me/entity#1234')): tags,
+            self.graph.node(ns.bsfs.Entity, URI('http://example.com/me/entity#4321')): tags,
+            })
+        self.assertDictEqual(walk(), {
+            self.graph.node(ns.bsfs.Entity, URI('http://example.com/me/entity#1234')): tags,
+            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)))
+        # get returns values if need be
+        self.assertSetEqual(walk.label(node=True), {'hello', 'world'})
+
+
+## main ##
+
+if __name__ == '__main__':
+    unittest.main()
+
+## EOF ##