triple store Open interface

5 files changed, 23 insertions, 28 deletions

diff --git a/bsfs/triple_store/base.py b/bsfs/triple_store/base.py
index a2668c3..942a16b 100644
--- a/bsfs/triple_store/base.py
+++ b/bsfs/triple_store/base.py
@@ -54,11 +54,7 @@ class TripleStoreBase(abc.ABC):
 
     @classmethod
     @abc.abstractmethod
-    def Open(
-            cls,
-            uri: str,
-            **kwargs: typing.Any,
-            ) -> 'TripleStoreBase':
+    def Open(cls, **kwargs: typing.Any) -> 'TripleStoreBase': # pylint: disable=invalid-name # capitalized classmethod
         """Return a TripleStoreBase instance connected to *uri*."""
 
     @abc.abstractmethod
@@ -75,6 +71,7 @@ class TripleStoreBase(abc.ABC):
         """Return the store's local schema."""
 
     @schema.setter
+    @abc.abstractmethod
     def schema(self, schema: _schema.Schema):
         """Migrate to new schema by adding or removing class definitions.
 
diff --git a/bsfs/triple_store/sparql.py b/bsfs/triple_store/sparql.py
index d9ed55a..fc161b3 100644
--- a/bsfs/triple_store/sparql.py
+++ b/bsfs/triple_store/sparql.py
@@ -72,13 +72,11 @@ class SparqlStore(base.TripleStoreBase):
         self._transaction = _Transaction(self._graph)
         self._schema = bsc.Schema.Empty()
 
+    # NOTE: mypy and pylint complain about the **kwargs not being listed (contrasting super)
+    # However, not having it here is clearer since it's explicit that there are no arguments.
     @classmethod
-    def Open(
-            cls,
-            uri: str,
-            **kwargs: typing.Any,
-            ) -> 'SparqlStore':
-        return cls(None)
+    def Open(cls) -> 'SparqlStore': # type: ignore [override] # pylint: disable=arguments-differ
+        return cls()
 
     def commit(self):
         self._transaction.commit()
diff --git a/test/graph/test_graph.py b/test/graph/test_graph.py
index 0b16527..f8e107d 100644
--- a/test/graph/test_graph.py
+++ b/test/graph/test_graph.py
@@ -23,7 +23,7 @@ from bsfs.graph.graph import Graph
 class TestGraph(unittest.TestCase):
     def setUp(self):
         self.user = URI('http://example.com/me')
-        self.backend = SparqlStore.Open(None)
+        self.backend = SparqlStore.Open()
         self.backend.schema = schema.Schema.from_string('''
             prefix rdfs: <http://www.w3.org/2000/01/rdf-schema#>
             prefix bsfs: <http://bsfs.ai/schema/>
@@ -37,9 +37,9 @@ class TestGraph(unittest.TestCase):
             'Graph(backend=SparqlStore(uri=None), user=http://example.com/me)')
         # str respects backend
         class Foo(SparqlStore): pass
-        self.assertEqual(str(Graph(Foo.Open(None), self.user)),
+        self.assertEqual(str(Graph(Foo.Open(), self.user)),
             'Graph(Foo(uri=None), http://example.com/me)')
-        self.assertEqual(repr(Graph(Foo.Open(None), self.user)),
+        self.assertEqual(repr(Graph(Foo.Open(), self.user)),
             'Graph(backend=Foo(uri=None), user=http://example.com/me)')
         # str respect user
         self.assertEqual(str(Graph(self.backend, URI('http://example.com/you'))),
@@ -62,8 +62,8 @@ class TestGraph(unittest.TestCase):
         self.assertEqual(graph, Graph(self.backend, self.user))
         self.assertEqual(hash(graph), hash(Graph(self.backend, self.user)))
         # equality respects backend
-        self.assertNotEqual(graph, Graph(SparqlStore.Open(None), self.user))
-        self.assertNotEqual(hash(graph), hash(Graph(SparqlStore.Open(None), self.user)))
+        self.assertNotEqual(graph, Graph(SparqlStore.Open(), self.user))
+        self.assertNotEqual(hash(graph), hash(Graph(SparqlStore.Open(), self.user)))
         # equality respects user
         self.assertNotEqual(graph, Graph(self.backend, URI('http://example.com/you')))
         self.assertNotEqual(hash(graph), hash(Graph(self.backend, URI('http://example.com/you'))))
diff --git a/test/graph/test_nodes.py b/test/graph/test_nodes.py
index 71fbb10..43e7f6f 100644
--- a/test/graph/test_nodes.py
+++ b/test/graph/test_nodes.py
@@ -107,7 +107,7 @@ class TestNodes(unittest.TestCase):
         self.assertEqual(repr(nodes), f'Nodes({self.backend}, {self.user}, {self.ent_type}, {{\'http://example.com/me/entity#foo\'}})')
         # repr respects backend
         class Foo(SparqlStore): pass
-        backend = Foo.Open(None)
+        backend = Foo.Open()
         backend.schema = self.backend.schema
         nodes = Nodes(backend, self.user, self.ent_type, self.ent_ids)
         self.assertEqual(repr(nodes), f'Nodes({backend}, {self.user}, {self.ent_type}, {self.ent_ids})')
@@ -125,7 +125,7 @@ class TestNodes(unittest.TestCase):
         self.assertEqual(Nodes(self.backend, self.user, self.ent_type, self.ent_ids), nodes)
         self.assertEqual(hash(nodes), hash(Nodes(self.backend, self.user, self.ent_type, self.ent_ids)))
         # equality respects backend
-        backend = SparqlStore.Open(None)
+        backend = SparqlStore.Open()
         backend.schema = self.backend.schema
         self.assertNotEqual(nodes, Nodes(backend, self.user, self.ent_type, self.ent_ids))
         self.assertNotEqual(hash(nodes), hash(Nodes(backend, self.user, self.ent_type, self.ent_ids)))
diff --git a/test/triple_store/test_sparql.py b/test/triple_store/test_sparql.py
index ecf3a07..c4925c4 100644
--- a/test/triple_store/test_sparql.py
+++ b/test/triple_store/test_sparql.py
@@ -61,22 +61,22 @@ class TestSparqlStore(unittest.TestCase):
             ''')
 
     def test_essentials(self):
-        store = SparqlStore(None)
+        store = SparqlStore.Open()
         # equality
         self.assertEqual(store, store)
         self.assertEqual(hash(store), hash(store))
-        self.assertNotEqual(store, SparqlStore(None))
-        self.assertNotEqual(hash(store), hash(SparqlStore(None)))
+        self.assertNotEqual(store, SparqlStore.Open())
+        self.assertNotEqual(hash(store), hash(SparqlStore.Open()))
         # string conversion
         self.assertEqual(str(store), 'SparqlStore(uri=None)')
         self.assertEqual(repr(store), 'SparqlStore(uri=None)')
         # open
-        self.assertIsInstance(SparqlStore.Open(None), SparqlStore)
+        self.assertIsInstance(SparqlStore.Open(), SparqlStore)
 
 
     def test__has_type(self):
         # setup store
-        store = SparqlStore(None)
+        store = SparqlStore.Open()
         store.schema = _schema.Schema.from_string('''
             prefix rdfs: <http://www.w3.org/2000/01/rdf-schema#>
             prefix xsd: <http://www.w3.org/2001/XMLSchema#>
@@ -129,7 +129,7 @@ class TestSparqlStore(unittest.TestCase):
 
     def test_schema(self):
         # setup
-        store = SparqlStore(None)
+        store = SparqlStore.Open()
         curr = self.schema
         p_comment = curr.predicate(ns.bse.comment)
         p_filesize = curr.predicate(ns.bse.filesize)
@@ -380,7 +380,7 @@ class TestSparqlStore(unittest.TestCase):
 
     def test_transaction(self):
         # store setup
-        store = SparqlStore(None)
+        store = SparqlStore.Open()
         store.schema = self.schema
         p_tag = store.schema.predicate(ns.bse.tag)
         p_filesize = store.schema.predicate(ns.bse.filesize)
@@ -458,7 +458,7 @@ class TestSparqlStore(unittest.TestCase):
 
     def test_exists(self):
         # store setup
-        store = SparqlStore(None)
+        store = SparqlStore.Open()
         store.schema = self.schema
         # prepare node types
         ent_type = store.schema.node(ns.bsfs.Entity)
@@ -497,7 +497,7 @@ class TestSparqlStore(unittest.TestCase):
 
     def test_create(self):
         # setup
-        store = SparqlStore(None)
+        store = SparqlStore.Open()
         store.schema = self.schema
 
         # node type must be valid
@@ -551,7 +551,7 @@ class TestSparqlStore(unittest.TestCase):
 
     def test_set(self):
         # store setup
-        store = SparqlStore(None)
+        store = SparqlStore.Open()
         store.schema = self.schema
         # prepare node types
         ent_type = store.schema.node(ns.bsfs.Entity)