information hiding

1 files changed, 29 insertions, 29 deletions

diff --git a/bsfs/graph/nodes.py b/bsfs/graph/nodes.py
index 7d2e9b3..7b0e8f4 100644
--- a/bsfs/graph/nodes.py
+++ b/bsfs/graph/nodes.py
@@ -32,16 +32,16 @@ class Nodes():
     """
 
     # triple store backend.
-    __backend: TripleStoreBase
+    _backend: TripleStoreBase
 
     # user uri.
-    __user: URI
+    _user: URI
 
     # node type.
-    __node_type: _schema.Node
+    _node_type: _schema.Node
 
     # guids of nodes. Can be empty.
-    __guids: typing.Set[URI]
+    _guids: typing.Set[URI]
 
     def __init__(
             self,
@@ -50,37 +50,37 @@ class Nodes():
             node_type: _schema.Node,
             guids: typing.Iterable[URI],
             ):
-        self.__backend = backend
-        self.__user = user
-        self.__node_type = node_type
-        self.__guids = set(guids)
-        self.__ac = ac.NullAC(self.__backend, self.__user)
+        self._backend = backend
+        self._user = user
+        self._node_type = node_type
+        self._guids = set(guids)
+        self.__ac = ac.NullAC(self._backend, self._user)
 
     def __eq__(self, other: typing.Any) -> bool:
         return isinstance(other, Nodes) \
-           and self.__backend == other.__backend \
-           and self.__user == other.__user \
-           and self.__node_type == other.__node_type \
-           and self.__guids == other.__guids
+           and self._backend == other._backend \
+           and self._user == other._user \
+           and self._node_type == other._node_type \
+           and self._guids == other._guids
 
     def __hash__(self) -> int:
-        return hash((type(self), self.__backend, self.__user, self.__node_type, tuple(sorted(self.__guids))))
+        return hash((type(self), self._backend, self._user, self._node_type, tuple(sorted(self._guids))))
 
     def __repr__(self) -> str:
-        return f'{typename(self)}({self.__backend}, {self.__user}, {self.__node_type}, {self.__guids})'
+        return f'{typename(self)}({self._backend}, {self._user}, {self._node_type}, {self._guids})'
 
     def __str__(self) -> str:
-        return f'{typename(self)}({self.__node_type}, {self.__guids})'
+        return f'{typename(self)}({self._node_type}, {self._guids})'
 
     @property
     def node_type(self) -> _schema.Node:
         """Return the node's type."""
-        return self.__node_type
+        return self._node_type
 
     @property
     def guids(self) -> typing.Iterator[URI]:
         """Return all node guids."""
-        return iter(self.__guids)
+        return iter(self._guids)
 
     def set(
             self,
@@ -93,7 +93,7 @@ class Nodes():
             # insert triples
             self.__set(pred, value)
             # save changes
-            self.__backend.commit()
+            self._backend.commit()
 
         except (
                 errors.PermissionDeniedError, # tried to set a protected predicate (ns.bsm.t_created)
@@ -103,7 +103,7 @@ class Nodes():
                 ValueError, # multiple values passed to unique predicate
                 ):
             # revert changes
-            self.__backend.rollback()
+            self._backend.rollback()
             # notify the client
             raise
 
@@ -123,7 +123,7 @@ class Nodes():
             for pred, value in predicate_values:
                 self.__set(pred, value)
             # save changes
-            self.__backend.commit()
+            self._backend.commit()
 
         except (
                 errors.PermissionDeniedError, # tried to set a protected predicate (ns.bsm.t_created)
@@ -133,7 +133,7 @@ class Nodes():
                 ValueError, # multiple values passed to unique predicate
                 ):
             # revert changes
-            self.__backend.rollback()
+            self._backend.rollback()
             # notify the client
             raise
 
@@ -148,7 +148,7 @@ class Nodes():
         """
         """
         # get normalized predicate. Raises KeyError if *pred* not in the schema.
-        pred = self.__backend.schema.predicate(predicate)
+        pred = self._backend.schema.predicate(predicate)
 
         # node_type must be a subclass of the predicate's domain
         node_type = self.node_type
@@ -177,7 +177,7 @@ class Nodes():
 
             # insert literals
             # TODO: Support passing iterators as values for non-unique predicates
-            self.__backend.set(
+            self._backend.set(
                 node_type,
                 guids,
                 pred,
@@ -206,7 +206,7 @@ class Nodes():
             targets = set(self.__ac.link_to_node(value.node_type, targets))
 
             # insert node links
-            self.__backend.set(
+            self._backend.set(
                 node_type,
                 guids,
                 pred,
@@ -223,7 +223,7 @@ class Nodes():
             ):
         # check node existence
         guids = set(guids)
-        existing = set(self.__backend.exists(node_type, guids))
+        existing = set(self._backend.exists(node_type, guids))
         # get nodes to be created
         missing = guids - existing
         # create nodes if need be
@@ -231,10 +231,10 @@ class Nodes():
             # check which missing nodes can be created
             missing = set(self.__ac.createable(node_type, missing))
             # create nodes
-            self.__backend.create(node_type, missing)
+            self._backend.create(node_type, missing)
             # add bookkeeping triples
-            self.__backend.set(node_type, missing,
-                self.__backend.schema.predicate(ns.bsm.t_created), [time.time()])
+            self._backend.set(node_type, missing,
+                self._backend.schema.predicate(ns.bsm.t_created), [time.time()])
             # add permission triples
             self.__ac.create(node_type, missing)
         # return available nodes