use Vertex in type annotations

1 files changed, 18 insertions, 21 deletions

diff --git a/bsfs/triple_store/sparql/parse_filter.py b/bsfs/triple_store/sparql/parse_filter.py
index d4db0aa..a851888 100644
--- a/bsfs/triple_store/sparql/parse_filter.py
+++ b/bsfs/triple_store/sparql/parse_filter.py
@@ -46,9 +46,6 @@ class Filter():
     # Generator that produces unique symbol names.
     ngen: _GenHopName
 
-    # Vertex type.
-    T_VERTEX = typing.Union[bsc.Node, bsc.Literal]
-
     def __init__(self, schema):
         self.schema = schema
         self.ngen = _GenHopName()
@@ -79,7 +76,7 @@ class Filter():
             }}
             '''
 
-    def _parse_filter_expression(self, type_: T_VERTEX, node: ast.filter.FilterExpression, head: str) -> str:
+    def _parse_filter_expression(self, type_: bsc.Vertex, node: ast.filter.FilterExpression, head: str) -> str:
         """Route *node* to the handler of the respective FilterExpression subclass."""
         if isinstance(node, ast.filter.Is):
             return self._is(type_, node, head)
@@ -112,9 +109,9 @@ class Filter():
 
     def _parse_predicate_expression(
             self,
-            type_: T_VERTEX,
+            type_: bsc.Vertex,
             node: ast.filter.PredicateExpression
-            ) -> typing.Tuple[str, T_VERTEX]:
+            ) -> typing.Tuple[str, bsc.Vertex]:
         """Route *node* to the handler of the respective PredicateExpression subclass."""
         if isinstance(node, ast.filter.Predicate):
             return self._predicate(type_, node)
@@ -123,7 +120,7 @@ class Filter():
         # invalid node
         raise errors.BackendError(f'expected predicate expression, found {node}')
 
-    def _one_of(self, node_type: T_VERTEX, node: ast.filter.OneOf) -> typing.Tuple[str, T_VERTEX]:
+    def _one_of(self, node_type: bsc.Vertex, node: ast.filter.OneOf) -> typing.Tuple[str, bsc.Vertex]:
         """
         """
         if not isinstance(node_type, bsc.Node):
@@ -150,7 +147,7 @@ class Filter():
         # return joint predicate expression and next range
         return '|'.join(suburi), rng
 
-    def _predicate(self, node_type: T_VERTEX, node: ast.filter.Predicate) -> typing.Tuple[str, T_VERTEX]:
+    def _predicate(self, node_type: bsc.Vertex, node: ast.filter.Predicate) -> typing.Tuple[str, bsc.Vertex]:
         """
         """
         # check node_type
@@ -178,7 +175,7 @@ class Filter():
         # return predicate URI and next node type
         return puri, rng
 
-    def _any(self, node_type: T_VERTEX, node: ast.filter.Any, head: str) -> str:
+    def _any(self, node_type: bsc.Vertex, node: ast.filter.Any, head: str) -> str:
         """
         """
         if not isinstance(node_type, bsc.Node):
@@ -191,7 +188,7 @@ class Filter():
         # combine results
         return f'{head} {pred} {nexthead} . {expr}'
 
-    def _all(self, node_type: T_VERTEX, node: ast.filter.All, head: str) -> str:
+    def _all(self, node_type: bsc.Vertex, node: ast.filter.All, head: str) -> str:
         """
         """
         # NOTE: All(P, E) := Not(Any(P, Not(E))) and EXISTS(P, ?)
@@ -208,13 +205,13 @@ class Filter():
         # return existence and rewritten expression
         return f'FILTER EXISTS {{ {head} {pred} {temphead} }} . ' + expr
 
-    def _and(self, node_type: T_VERTEX, node: ast.filter.And, head: str) -> str:
+    def _and(self, node_type: bsc.Vertex, node: ast.filter.And, head: str) -> str:
         """
         """
         sub = [self._parse_filter_expression(node_type, expr, head) for expr in node]
         return ' . '.join(sub)
 
-    def _or(self, node_type: T_VERTEX, node: ast.filter.Or, head: str) -> str:
+    def _or(self, node_type: bsc.Vertex, node: ast.filter.Or, head: str) -> str:
         """
         """
         # potential special case optimization:
@@ -224,7 +221,7 @@ class Filter():
         sub = ['{' + expr + '}' for expr in sub]
         return ' UNION '.join(sub)
 
-    def _not(self, node_type: T_VERTEX, node: ast.filter.Not, head: str) -> str:
+    def _not(self, node_type: bsc.Vertex, node: ast.filter.Not, head: str) -> str:
         """
         """
         expr = self._parse_filter_expression(node_type, node.expr, head)
@@ -235,7 +232,7 @@ class Filter():
         # The simplest (and non-interfering) choice is a type statement.
         return f'MINUS {{ {head} <{ns.rdf.type}>/<{ns.rdfs.subClassOf}>* <{node_type.uri}> . {expr} }}'
 
-    def _has(self, node_type: T_VERTEX, node: ast.filter.Has, head: str) -> str:
+    def _has(self, node_type: bsc.Vertex, node: ast.filter.Has, head: str) -> str:
         """
         """
         if not isinstance(node_type, bsc.Node):
@@ -253,42 +250,42 @@ class Filter():
         # combine
         return num_preds + ' . ' + count_bounds
 
-    def _is(self, node_type: T_VERTEX, node: ast.filter.Is, head: str) -> str:
+    def _is(self, node_type: bsc.Vertex, node: ast.filter.Is, head: str) -> str:
         """
         """
         if not isinstance(node_type, bsc.Node):
             raise errors.BackendError(f'expected Node, found {node_type}')
         return f'VALUES {head} {{ <{node.value}> }}'
 
-    def _equals(self, node_type: T_VERTEX, node: ast.filter.Equals, head: str) -> str:
+    def _equals(self, node_type: bsc.Vertex, node: ast.filter.Equals, head: str) -> str:
         """
         """
         if not isinstance(node_type, bsc.Literal):
             raise errors.BackendError(f'expected Literal, found {node}')
         return f'VALUES {head} {{ "{node.value}"^^<{node_type.uri}> }}'
 
-    def _substring(self, node_type: T_VERTEX, node: ast.filter.Substring, head: str) -> str:
+    def _substring(self, node_type: bsc.Vertex, node: ast.filter.Substring, head: str) -> str:
         """
         """
         if not isinstance(node_type, bsc.Literal):
             raise errors.BackendError(f'expected Literal, found {node_type}')
         return f'FILTER contains(str({head}), "{node.value}")'
 
-    def _starts_with(self, node_type: T_VERTEX, node: ast.filter.StartsWith, head: str) -> str:
+    def _starts_with(self, node_type: bsc.Vertex, node: ast.filter.StartsWith, head: str) -> str:
         """
         """
         if not isinstance(node_type, bsc.Literal):
             raise errors.BackendError(f'expected Literal, found {node_type}')
         return f'FILTER strstarts(str({head}), "{node.value}")'
 
-    def _ends_with(self, node_type: T_VERTEX, node: ast.filter.EndsWith, head: str) -> str:
+    def _ends_with(self, node_type: bsc.Vertex, node: ast.filter.EndsWith, head: str) -> str:
         """
         """
         if not isinstance(node_type, bsc.Literal):
             raise errors.BackendError(f'expected Literal, found {node_type}')
         return f'FILTER strends(str({head}), "{node.value}")'
 
-    def _less_than(self, node_type: T_VERTEX, node: ast.filter.LessThan, head: str) -> str:
+    def _less_than(self, node_type: bsc.Vertex, node: ast.filter.LessThan, head: str) -> str:
         """
         """
         if not isinstance(node_type, bsc.Literal):
@@ -296,7 +293,7 @@ class Filter():
         equality = '=' if not node.strict else ''
         return f'FILTER ({head} <{equality} {float(node.threshold)})'
 
-    def _greater_than(self, node_type: T_VERTEX, node: ast.filter.GreaterThan, head: str) -> str:
+    def _greater_than(self, node_type: bsc.Vertex, node: ast.filter.GreaterThan, head: str) -> str:
         """
         """
         if not isinstance(node_type, bsc.Literal):