schema type comparison across classes

4 files changed, 35 insertions, 37 deletions

diff --git a/bsfs/graph/resolve.py b/bsfs/graph/resolve.py
index 9b5f631..b671204 100644
--- a/bsfs/graph/resolve.py
+++ b/bsfs/graph/resolve.py
@@ -96,11 +96,11 @@ class Filter():
             # parse child expression
             subrng = self._parse_predicate_expression(pred)
             # determine the next type
-            try:
-                if rng is None or subrng > rng: # pick most generic range
-                    rng = subrng
-            except TypeError as err:
-                raise errors.ConsistencyError(f'ranges {subrng} and {rng} are not related') from err
+            if rng is None or subrng > rng: # pick most generic range
+                rng = subrng
+            # check range consistency
+            if not subrng <= rng and not subrng >= rng:
+                raise errors.ConsistencyError(f'ranges {subrng} and {rng} are not related')
         if not isinstance(rng, (bsc.Node, bsc.Literal)):
             raise errors.BackendError(f'the range of node {node} is undefined')
         return rng
diff --git a/bsfs/query/validator.py b/bsfs/query/validator.py
index 75b51ca..ecea951 100644
--- a/bsfs/query/validator.py
+++ b/bsfs/query/validator.py
@@ -113,25 +113,18 @@ class Filter():
         for pred in node:
             # parse child expression
             subdom, subrng = self._parse_predicate_expression(pred)
-            try:
-                # determine overall domain
-                if dom is None or subdom < dom: # pick most specific domain
-                    dom = subdom
-                # domains must be related across all child expressions
-                if not subdom <= dom and not subdom >= dom:
-                    raise errors.ConsistencyError(f'domains {subdom} and {dom} are not related')
-            except TypeError as err: # compared literal vs. node
-                raise errors.ConsistencyError(f'domains {subdom} and {dom} are not of the same type') from err
-
-            try:
-                # determine overall range
-                if rng is None or subrng > rng: # pick most generic range
-                    rng = subrng
-                # ranges must be related across all child expressions
-                if not subrng <= rng and not subrng >= rng:
-                    raise errors.ConsistencyError(f'ranges {subrng} and {rng} are not related')
-            except TypeError as err: # compared literal vs. node
-                raise errors.ConsistencyError(f'ranges {subrng} and {rng} are not of the same type') from err
+            # determine overall domain
+            if dom is None or subdom < dom: # pick most specific domain
+                dom = subdom
+            # domains must be related across all child expressions
+            if not subdom <= dom and not subdom >= dom:
+                raise errors.ConsistencyError(f'domains {subdom} and {dom} are not related')
+            # determine overall range
+            if rng is None or subrng > rng: # pick most generic range
+                rng = subrng
+            # ranges must be related across all child expressions
+            if not subrng <= rng and not subrng >= rng:
+                raise errors.ConsistencyError(f'ranges {subrng} and {rng} are not related')
         # OneOf guarantees at least one expression, dom and rng are always bsc.Vertex.
         # mypy does not realize this, hence we ignore the warning.
         return dom, rng # type: ignore [return-value]
diff --git a/bsfs/schema/types.py b/bsfs/schema/types.py
index 6257dee..95dc66a 100644
--- a/bsfs/schema/types.py
+++ b/bsfs/schema/types.py
@@ -150,8 +150,10 @@ class _Type():
 
     def __lt__(self, other: typing.Any) -> bool:
         """Return True iff *self* is a true subclass of *other*."""
-        if not isinstance(other, type(self)):
+        if not isinstance(other, _Type):
             return NotImplemented
+        if not isinstance(other, type(self)): # FIXME: necessary?
+            return False
         if self.uri == other.uri: # equivalence
             return False
         if self in other.parents(): # superclass
@@ -163,8 +165,10 @@ class _Type():
 
     def __le__(self, other: typing.Any) -> bool:
         """Return True iff *self* is equivalent or a subclass of *other*."""
-        if not isinstance(other, type(self)):
+        if not isinstance(other, _Type):
             return NotImplemented
+        if not isinstance(other, type(self)): # FIXME: necessary?
+            return False
         if self.uri == other.uri: # equivalence
             return True
         if self in other.parents(): # superclass
@@ -176,8 +180,10 @@ class _Type():
 
     def __gt__(self, other: typing.Any) -> bool:
         """Return True iff *self* is a true superclass of *other*."""
-        if not isinstance(other, type(self)):
+        if not isinstance(other, _Type):
             return NotImplemented
+        if not isinstance(other, type(self)): # FIXME: necessary?
+            return False
         if self.uri == other.uri: # equivalence
             return False
         if self in other.parents(): # superclass
@@ -189,8 +195,10 @@ class _Type():
 
     def __ge__(self, other: typing.Any) -> bool:
         """Return True iff *self* is eqiuvalent or a superclass of *other*."""
-        if not isinstance(other, type(self)):
+        if not isinstance(other, _Type):
             return NotImplemented
+        if not isinstance(other, type(self)): # FIXME: necessary?
+            return False
         if self.uri == other.uri: # equivalence
             return True
         if self in other.parents(): # superclass
diff --git a/bsfs/triple_store/sparql/parse_filter.py b/bsfs/triple_store/sparql/parse_filter.py
index 18a3288..5d8a2d9 100644
--- a/bsfs/triple_store/sparql/parse_filter.py
+++ b/bsfs/triple_store/sparql/parse_filter.py
@@ -131,15 +131,12 @@ class Filter():
             puri, subrng = self._parse_predicate_expression(node_type, pred)
             # track predicate uris
             suburi.add(puri)
-            try:
-                # check for more generic range
-                if rng is None or subrng > rng:
-                    rng = subrng
-                # check range consistency
-                if not subrng <= rng and not subrng >= rng:
-                    raise errors.ConsistencyError(f'ranges {subrng} and {rng} are not related')
-            except TypeError as err: # subrng and rng are not comparable
-                raise errors.ConsistencyError(f'ranges {subrng} and {rng} are not related') from err
+            # check for more generic range
+            if rng is None or subrng > rng:
+                rng = subrng
+            # check range consistency
+            if not subrng <= rng and not subrng >= rng:
+                raise errors.ConsistencyError(f'ranges {subrng} and {rng} are not related')
         # return joint predicate expression and next range
         # OneOf guarantees at least one expression, rng is always a bsc.Vertex.
         # mypy does not realize this, hence we ignore the warning.