Merge branch 'mb/features' into develop

3 files changed, 159 insertions, 23 deletions

diff --git a/test/triple_store/sparql/test_distance.py b/test/triple_store/sparql/test_distance.py
new file mode 100644
index 0000000..0659459
--- /dev/null
+++ b/test/triple_store/sparql/test_distance.py
@@ -0,0 +1,61 @@
+"""
+
+Part of the bsfs test suite.
+A copy of the license is provided with the project.
+Author: Matthias Baumgartner, 2022
+"""
+# imports
+import numpy as np
+import unittest
+
+# objects to test
+from bsfs.triple_store.sparql import distance
+
+
+## code ##
+
+class TestDistance(unittest.TestCase):
+
+    def test_euclid(self):
+        # self-distance is zero
+        self.assertEqual(distance.euclid([1,2,3,4], [1,2,3,4]), 0.0)
+        # accepts list-like arguments
+        self.assertAlmostEqual(distance.euclid([1,2,3,4], [2,3,4,5]), 2.0, 3)
+        self.assertAlmostEqual(distance.euclid((1,2,3,4), (2,3,4,5)), 2.0, 3)
+        # dimension can vary
+        self.assertAlmostEqual(distance.euclid([1,2,3], [2,3,4]), 1.732, 3)
+        self.assertAlmostEqual(distance.euclid([1,2,3,4,5], [2,3,4,5,6]), 2.236, 3)
+        # vector can be zero
+        self.assertAlmostEqual(distance.euclid([0,0,0], [1,2,3]), 3.742, 3)
+
+    def test_cosine(self):
+        # self-distance is zero
+        self.assertEqual(distance.cosine([1,2,3,4], [1,2,3,4]), 0.0)
+        # accepts list-like arguments
+        self.assertAlmostEqual(distance.cosine([1,2,3,4], [4,3,2,1]), 0.333, 3)
+        self.assertAlmostEqual(distance.cosine((1,2,3,4), (4,3,2,1)), 0.333, 3)
+        # dimension can vary
+        self.assertAlmostEqual(distance.cosine([1,2,3], [3,2,1]), 0.286, 3)
+        self.assertAlmostEqual(distance.cosine([1,2,3,4,5], [5,4,3,2,1]), 0.364, 3)
+        # vector can be zero
+        self.assertAlmostEqual(distance.cosine([0,0,0], [1,2,3]), 1.0, 3)
+
+    def test_manhatten(self):
+        # self-distance is zero
+        self.assertEqual(distance.manhatten([1,2,3,4], [1,2,3,4]), 0.0)
+        # accepts list-like arguments
+        self.assertAlmostEqual(distance.manhatten([1,2,3,4], [2,3,4,5]), 4.0, 3)
+        self.assertAlmostEqual(distance.manhatten((1,2,3,4), (2,3,4,5)), 4.0, 3)
+        # dimension can vary
+        self.assertAlmostEqual(distance.manhatten([1,2,3], [2,3,4]), 3.0, 3)
+        self.assertAlmostEqual(distance.manhatten([1,2,3,4,5], [2,3,4,5,6]), 5.0, 3)
+        # vector can be zero
+        self.assertAlmostEqual(distance.manhatten([0,0,0], [1,2,3]), 6.0, 3)
+
+
+## main ##
+
+if __name__ == '__main__':
+    unittest.main()
+
+## EOF ##
diff --git a/test/triple_store/sparql/test_parse_filter.py b/test/triple_store/sparql/test_parse_filter.py
index bd19803..8764535 100644
--- a/test/triple_store/sparql/test_parse_filter.py
+++ b/test/triple_store/sparql/test_parse_filter.py
@@ -9,7 +9,7 @@ import rdflib
 import unittest
 
 # bsie imports
-from bsfs import schema as _schema
+from bsfs import schema as bsc
 from bsfs.namespace import ns
 from bsfs.query import ast
 from bsfs.utils import errors
@@ -23,21 +23,34 @@ from bsfs.triple_store.sparql.parse_filter import Filter
 class TestParseFilter(unittest.TestCase):
     def setUp(self):
         # schema
-        self.schema = _schema.Schema.from_string('''
+        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#>
 
+            bsfs:Array rdfs:subClassOf bsfs:Literal .
+            bsfs:Feature rdfs:subClassOf bsfs:Array .
+            bsfs:Number rdfs:subClassOf bsfs:Literal .
+
             bsfs:Entity rdfs:subClassOf bsfs:Node .
             bsfs:Image rdfs:subClassOf bsfs:Entity .
             bsfs:Tag rdfs:subClassOf bsfs:Node .
 
             xsd:string rdfs:subClassOf bsfs:Literal .
-            xsd:integer rdfs:subClassOf bsfs:Literal .
+            xsd:integer rdfs:subClassOf bsfs:Number .
             bsfs:URI rdfs:subClassOf bsfs:Literal .
 
+            bsfs:Colors rdfs:subClassOf bsfs:Feature ;
+                bsfs:dimension "4"^^xsd:integer ;
+                bsfs:dtype xsd:integer ;
+                bsfs:distance bsfs:euclidean .
+
+            bse:colors rdfs:subClassOf bsfs:Predicate ;
+                rdfs:domain bsfs:Entity ;
+                rdfs:range bsfs:Colors .
+
             bse:comment rdfs:subClassOf bsfs:Predicate ;
                 rdfs:domain bsfs:Node ;
                 rdfs:range xsd:string ;
@@ -70,9 +83,6 @@ class TestParseFilter(unittest.TestCase):
 
             ''')
 
-        # parser instance
-        self.parser = Filter(self.schema)
-
         # graph to test queries
         self.graph = rdflib.Graph()
         # schema hierarchies
@@ -113,6 +123,13 @@ class TestParseFilter(unittest.TestCase):
         # image iso
         self.graph.add((rdflib.URIRef('http://example.com/image#1234'), rdflib.URIRef(ns.bse.iso), rdflib.Literal(1234, datatype=rdflib.XSD.integer)))
         self.graph.add((rdflib.URIRef('http://example.com/image#4321'), rdflib.URIRef(ns.bse.iso), rdflib.Literal(4321, datatype=rdflib.XSD.integer)))
+        # color features
+        self.graph.add((rdflib.URIRef('http://example.com/entity#1234'), rdflib.URIRef(ns.bse.colors), rdflib.Literal([1,2,3,4], datatype=rdflib.URIRef(ns.bsfs.Colors))))
+        self.graph.add((rdflib.URIRef('http://example.com/entity#4321'), rdflib.URIRef(ns.bse.colors), rdflib.Literal([4,3,2,1], datatype=rdflib.URIRef(ns.bsfs.Colors))))
+        self.graph.add((rdflib.URIRef('http://example.com/image#1234'), rdflib.URIRef(ns.bse.colors), rdflib.Literal([3,4,2,1], datatype=rdflib.URIRef(ns.bsfs.Colors))))
+
+        # parser instance
+        self.parser = Filter(self.graph, self.schema)
 
 
     def test_routing(self):
@@ -124,7 +141,7 @@ class TestParseFilter(unittest.TestCase):
 
         # __call__ requires a valid root type
         self.assertRaises(errors.BackendError, self.parser, self.schema.literal(ns.bsfs.Literal), None)
-        self.assertRaises(errors.ConsistencyError, self.parser, self.schema.node(ns.bsfs.Node).get_child(ns.bsfs.Invalid), None)
+        self.assertRaises(errors.ConsistencyError, self.parser, self.schema.node(ns.bsfs.Node).child(ns.bsfs.Invalid), None)
         # __call__ requires a parseable root
         self.assertRaises(errors.BackendError, self.parser, self.schema.node(ns.bsfs.Entity), ast.filter.FilterExpression())
         # __call__ returns an executable query
@@ -613,6 +630,37 @@ class TestParseFilter(unittest.TestCase):
             {'http://example.com/tag#1234'})
 
 
+    def test_distance(self):
+        # node          colors      distance to [2,4,3,1]
+        # entity#1234   [1,2,3,4]   3.742
+        # entity#4321   [4,3,2,1]   2.449
+        # image#1234    [3,4,2,1]   1.414
+
+        # _distance expects a feature
+        self.assertRaises(errors.BackendError, self.parser._distance, self.schema.node(ns.bsfs.Entity), ast.filter.Distance([1,2,3,4], 1), '')
+        # reference must have the correct dimension
+        self.assertRaises(errors.ConsistencyError, self.parser._distance, self.schema.literal(ns.bsfs.Colors), ast.filter.Distance([1,2,3], 1), '')
+        self.assertRaises(errors.ConsistencyError, self.parser._distance, self.schema.literal(ns.bsfs.Colors), ast.filter.Distance([1,2,3,4,5], 1), '')
+        # _distance respects threshold
+        q = self.parser(self.schema.node(ns.bsfs.Entity), ast.filter.Any(ns.bse.colors, ast.filter.Distance([2,4,3,1], 4)))
+        self.assertSetEqual({str(guid) for guid, in self.graph.query(q)},
+            {'http://example.com/entity#1234', 'http://example.com/entity#4321', 'http://example.com/image#1234'})
+        q = self.parser(self.schema.node(ns.bsfs.Entity), ast.filter.Any(ns.bse.colors, ast.filter.Distance([2,4,3,1], 3)))
+        self.assertSetEqual({str(guid) for guid, in self.graph.query(q)},
+            {'http://example.com/entity#4321', 'http://example.com/image#1234'})
+        q = self.parser(self.schema.node(ns.bsfs.Entity), ast.filter.Any(ns.bse.colors, ast.filter.Distance([2,4,3,1], 2)))
+        self.assertSetEqual({str(guid) for guid, in self.graph.query(q)},
+            {'http://example.com/image#1234'})
+        # result set can be empty
+        q = self.parser(self.schema.node(ns.bsfs.Entity), ast.filter.Any(ns.bse.colors, ast.filter.Distance([2,4,3,1], 1)))
+        self.assertSetEqual({str(guid) for guid, in self.graph.query(q)}, set())
+        # _distance respects strict
+        q = self.parser(self.schema.node(ns.bsfs.Entity), ast.filter.Any(ns.bse.colors, ast.filter.Distance([1,2,3,4], 0, False)))
+        self.assertSetEqual({str(guid) for guid, in self.graph.query(q)},
+            {'http://example.com/entity#1234'})
+        q = self.parser(self.schema.node(ns.bsfs.Entity), ast.filter.Any(ns.bse.colors, ast.filter.Distance([1,2,3,4], 0, True)))
+        self.assertSetEqual({str(guid) for guid, in self.graph.query(q)}, set())
+
     def test_one_of(self):
         # _one_of expects a node
         self.assertRaises(errors.BackendError, self.parser._one_of,
diff --git a/test/triple_store/sparql/test_sparql.py b/test/triple_store/sparql/test_sparql.py
index 3d81de1..7fbfb65 100644
--- a/test/triple_store/sparql/test_sparql.py
+++ b/test/triple_store/sparql/test_sparql.py
@@ -9,7 +9,7 @@ import rdflib
 import unittest
 
 # bsie imports
-from bsfs import schema as _schema
+from bsfs import schema as bsc
 from bsfs.namespace import ns
 from bsfs.query import ast
 from bsfs.utils import errors, URI
@@ -22,7 +22,7 @@ from bsfs.triple_store.sparql.sparql import SparqlStore
 
 class TestSparqlStore(unittest.TestCase):
     def setUp(self):
-        self.schema = _schema.Schema.from_string('''
+        self.schema = bsc.from_string('''
             prefix rdfs: <http://www.w3.org/2000/01/rdf-schema#>
             prefix xsd: <http://www.w3.org/2001/XMLSchema#>
 
@@ -33,7 +33,8 @@ class TestSparqlStore(unittest.TestCase):
             bsfs:Tag rdfs:subClassOf bsfs:Node .
             bsfs:User rdfs:subClassOf bsfs:Node .
             xsd:string rdfs:subClassOf bsfs:Literal .
-            xsd:integer rdfs:subClassOf bsfs:Literal .
+            bsfs:Number rdfs:subClassOf bsfs:Literal .
+            xsd:integer rdfs:subClassOf bsfs:Number .
 
             # non-unique literal
             bse:comment rdfs:subClassOf bsfs:Predicate ;
@@ -66,7 +67,11 @@ class TestSparqlStore(unittest.TestCase):
             (rdflib.URIRef(ns.bsfs.Tag), rdflib.RDFS.subClassOf, rdflib.URIRef(ns.bsfs.Node)),
             (rdflib.URIRef(ns.bsfs.User), rdflib.RDFS.subClassOf, rdflib.URIRef(ns.bsfs.Node)),
             (rdflib.URIRef(ns.xsd.string), rdflib.RDFS.subClassOf, rdflib.URIRef(ns.bsfs.Literal)),
-            (rdflib.URIRef(ns.xsd.integer), rdflib.RDFS.subClassOf, rdflib.URIRef(ns.bsfs.Literal)),
+            (rdflib.URIRef(ns.bsfs.Array), rdflib.RDFS.subClassOf, rdflib.URIRef(ns.bsfs.Literal)),
+            (rdflib.URIRef(ns.bsfs.Feature), rdflib.RDFS.subClassOf, rdflib.URIRef(ns.bsfs.Array)),
+            (rdflib.URIRef(ns.bsfs.Number), rdflib.RDFS.subClassOf, rdflib.URIRef(ns.bsfs.Literal)),
+            (rdflib.URIRef(ns.bsfs.Time), rdflib.RDFS.subClassOf, rdflib.URIRef(ns.bsfs.Literal)),
+            (rdflib.URIRef(ns.xsd.integer), rdflib.RDFS.subClassOf, rdflib.URIRef(ns.bsfs.Number)),
             (rdflib.URIRef(ns.bse.comment), rdflib.RDFS.subClassOf, rdflib.URIRef(ns.bsfs.Predicate)),
             (rdflib.URIRef(ns.bse.filesize), rdflib.RDFS.subClassOf, rdflib.URIRef(ns.bsfs.Predicate)),
             (rdflib.URIRef(ns.bse.tag), rdflib.RDFS.subClassOf, rdflib.URIRef(ns.bsfs.Predicate)),
@@ -90,7 +95,7 @@ class TestSparqlStore(unittest.TestCase):
     def test__has_type(self):
         # setup store
         store = SparqlStore.Open()
-        store.schema = _schema.Schema.from_string('''
+        store.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/>
@@ -108,7 +113,7 @@ class TestSparqlStore(unittest.TestCase):
         store.create(store.schema.node(ns.bsfs.PDF), {URI('http://example.com/me/pdf#1234')})
 
         # node_type must be in the schema
-        self.assertRaises(errors.ConsistencyError, store._has_type, URI('http://example.com/me/entity#1234'), store.schema.node(ns.bsfs.Node).get_child(ns.bsfs.invalid))
+        self.assertRaises(errors.ConsistencyError, store._has_type, URI('http://example.com/me/entity#1234'), store.schema.node(ns.bsfs.Node).child(ns.bsfs.invalid))
 
         # returns False on inexistent nodes
         self.assertFalse(store._has_type(URI('http://example.com/me/entity#4321'), store.schema.node(ns.bsfs.Entity)))
@@ -195,7 +200,7 @@ class TestSparqlStore(unittest.TestCase):
         self.assertSetEqual(set(store._graph), instances)
 
         # add some classes to the schema
-        curr = curr + _schema.Schema.from_string('''
+        curr = curr + 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/>
@@ -298,7 +303,7 @@ class TestSparqlStore(unittest.TestCase):
 
 
         # remove some classes from the schema
-        curr = _schema.Schema.from_string('''
+        curr = 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/>
@@ -310,7 +315,8 @@ class TestSparqlStore(unittest.TestCase):
             bsfs:User rdfs:subClassOf bsfs:Node .
 
             xsd:boolean rdfs:subClassOf bsfs:Literal .
-            xsd:integer rdfs:subClassOf bsfs:Literal .
+            bsfs:Number rdfs:subClassOf bsfs:Literal .
+            xsd:integer rdfs:subClassOf bsfs:Number .
 
             bse:filesize rdfs:subClassOf bsfs:Predicate ;
                 rdfs:domain bsfs:Entity ;
@@ -351,7 +357,11 @@ class TestSparqlStore(unittest.TestCase):
             (rdflib.URIRef(ns.bsfs.Tag), rdflib.RDFS.subClassOf, rdflib.URIRef(ns.bsfs.Node)),
             (rdflib.URIRef(ns.bsfs.User), rdflib.RDFS.subClassOf, rdflib.URIRef(ns.bsfs.Node)),
             (rdflib.URIRef(ns.xsd.boolean), rdflib.RDFS.subClassOf, rdflib.URIRef(ns.bsfs.Literal)),
-            (rdflib.URIRef(ns.xsd.integer), rdflib.RDFS.subClassOf, rdflib.URIRef(ns.bsfs.Literal)),
+            (rdflib.URIRef(ns.bsfs.Array), rdflib.RDFS.subClassOf, rdflib.URIRef(ns.bsfs.Literal)),
+            (rdflib.URIRef(ns.bsfs.Feature), rdflib.RDFS.subClassOf, rdflib.URIRef(ns.bsfs.Array)),
+            (rdflib.URIRef(ns.bsfs.Number), rdflib.RDFS.subClassOf, rdflib.URIRef(ns.bsfs.Literal)),
+            (rdflib.URIRef(ns.bsfs.Time), rdflib.RDFS.subClassOf, rdflib.URIRef(ns.bsfs.Literal)),
+            (rdflib.URIRef(ns.xsd.integer), rdflib.RDFS.subClassOf, rdflib.URIRef(ns.bsfs.Number)),
             (rdflib.URIRef(ns.bse.shared), rdflib.RDFS.subClassOf, rdflib.URIRef(ns.bsfs.Predicate)),
             (rdflib.URIRef(ns.bse.tag), rdflib.RDFS.subClassOf, rdflib.URIRef(ns.bsfs.Predicate)),
             (rdflib.URIRef(ns.bse.filesize), rdflib.RDFS.subClassOf, rdflib.URIRef(ns.bsfs.Predicate)),
@@ -382,8 +392,25 @@ class TestSparqlStore(unittest.TestCase):
         class Foo(): pass
         self.assertRaises(TypeError, setattr, store, 'schema', Foo())
 
+        # cannot define features w/o known distance function
+        invalid = 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#>
+
+            bsfs:Array rdfs:subClassOf bsfs:Literal .
+            bsfs:Feature rdfs:subClassOf bsfs:Array .
+
+            bsfs:Colors rdfs:subClassOf bsfs:Feature ;
+                bsfs:dimension "4"^^xsd:integer ;
+                bsfs:distance bsfs:foobar .
+
+            ''')
+        self.assertRaises(errors.UnsupportedError, setattr, store, 'schema', invalid)
+
         # cannot migrate to incompatible schema
-        invalid = _schema.Schema.from_string('''
+        invalid = 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/>
@@ -399,7 +426,7 @@ class TestSparqlStore(unittest.TestCase):
 
             ''')
         self.assertRaises(errors.ConsistencyError, setattr, store, 'schema', invalid)
-        invalid = _schema.Schema.from_string('''
+        invalid = 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/>
@@ -509,7 +536,7 @@ class TestSparqlStore(unittest.TestCase):
         store.set(ent_type, {URI('http://example.com/me/entity#1234')}, self.schema.predicate(ns.bse.filesize), {1234})
         store.set(ent_type, {URI('http://example.com/me/entity#4321')}, self.schema.predicate(ns.bse.filesize), {4321})
         # node_type must be in the schema
-        self.assertRaises(errors.ConsistencyError, set, store.get(self.schema.node(ns.bsfs.Node).get_child(ns.bsfs.Invalid), ast.filter.IsIn(ent_ids)))
+        self.assertRaises(errors.ConsistencyError, set, store.get(self.schema.node(ns.bsfs.Node).child(ns.bsfs.Invalid), ast.filter.IsIn(ent_ids)))
         # query must be a filter expression
         class Foo(): pass
         self.assertRaises(TypeError, set, store.get(ent_type, 1234))
@@ -574,7 +601,7 @@ class TestSparqlStore(unittest.TestCase):
         store.schema = self.schema
 
         # node type must be valid
-        self.assertRaises(errors.ConsistencyError, store.create, self.schema.node(ns.bsfs.Entity).get_child(ns.bsfs.invalid), {
+        self.assertRaises(errors.ConsistencyError, store.create, self.schema.node(ns.bsfs.Entity).child(ns.bsfs.invalid), {
             URI('http://example.com/me/entity#1234'), URI('http://example.com/me/entity#4321')})
 
         # can create some nodes
@@ -636,7 +663,7 @@ class TestSparqlStore(unittest.TestCase):
         p_comment = store.schema.predicate(ns.bse.comment)
         p_author = store.schema.predicate(ns.bse.author)
         p_tag = store.schema.predicate(ns.bse.tag)
-        p_invalid = store.schema.predicate(ns.bsfs.Predicate).get_child(ns.bsfs.foo, range=store.schema.node(ns.bsfs.Tag))
+        p_invalid = store.schema.predicate(ns.bsfs.Predicate).child(ns.bsfs.foo, range=store.schema.node(ns.bsfs.Tag))
         # create node instances
         ent_ids = {
             URI('http://example.com/me/entity#1234'),
@@ -659,7 +686,7 @@ class TestSparqlStore(unittest.TestCase):
         store.create(user_type, user_ids)
 
         # invalid node_type is not permitted
-        self.assertRaises(errors.ConsistencyError, store.set, self.schema.node(ns.bsfs.Node).get_child(ns.bse.foo),
+        self.assertRaises(errors.ConsistencyError, store.set, self.schema.node(ns.bsfs.Node).child(ns.bse.foo),
             ent_ids, p_comment, {'hello world'})
 
         # invalid predicate is not permitted