checkpoint

Author: aucampia

rdflib/plugins/sparql/__init__.py

@@ -1,5 +1,3 @@
-from __future__ import annotations
-
 """
 SPARQL implementation for RDFLib
 

rdflib/plugins/sparql/aggregates.py

@@ -106,10 +106,7 @@ def type_safe_numbers(*args: Union[Decimal, float, int]) -> Iterable[Union[float
     if any(isinstance(arg, float) for arg in args) and any(
         isinstance(arg, Decimal) for arg in args
     ):
-        # pytype error: bad return type
-        #  Expected: Tuple[Union[float, int]]
-        #  Actually returned: Iterator[float]
-        return map(float, args)  # pytype: disable=bad-return-type
+        return map(float, args)
     # type error: Incompatible return value type (got "Tuple[Union[Decimal, float, int], ...]", expected "Iterable[Union[float, int]]")
     # NOTE on type error: if args contains a Decimal it will nopt get here.
     return args  # type: ignore[return-value]
@@ -139,10 +136,7 @@ def update(self, row: FrozenBindings, aggregator: "Aggregator") -> None:
             pass
 
     def get_value(self) -> Literal:
-        # pytype error: Invalid keyword argument datatype to function Literal.__init__
-        return Literal(
-            self.value, datatype=self.datatype
-        )  # pytype: disable=wrong-keyword-args
+        return Literal(self.value, datatype=self.datatype)
 
 
 class Average(Accumulator):
@@ -203,18 +197,14 @@ def update(self, row: FrozenBindings, aggregator: "Aggregator") -> None:
                 self.value = _eval(self.expr, row)
             else:
                 # self.compare is implemented by Minimum/Maximum
-                # pytype error: No attribute 'compare' on Extremum
-                self.value = self.compare(
-                    self.value, _eval(self.expr, row)
-                )  # pytype: disable=attribute-error
+                self.value = self.compare(self.value, _eval(self.expr, row))
         # skip UNDEF or BNode => SPARQLTypeError
         except NotBoundError:
             pass
         except SPARQLTypeError:
             pass
 
 
-# _ValueT = TypeVar("_ValueT", bound=Union[Variable, BNode, URIRef, Literal])
 _ValueT = TypeVar("_ValueT", Variable, BNode, URIRef, Literal)
 
 
@@ -307,8 +297,7 @@ def update(self, row: FrozenBindings) -> None:
 
         for acc in list(self.accumulators.values()):
             if acc.use_row(row):
-                # pytype error: No attribute 'update' on Accumulator
-                acc.update(row, self)  # pytype: disable=attribute-error
+                acc.update(row, self)
 
     def get_bindings(self) -> Mapping[Variable, Identifier]:
         """calculate and set last values"""

rdflib/plugins/sparql/evaluate.py

@@ -1,7 +1,5 @@
 from __future__ import annotations
 
-from ...paths import Path
-
 """
 These method recursively evaluate the SPARQL Algebra
 
@@ -62,6 +60,9 @@
 )
 from rdflib.term import BNode, Identifier, Literal, URIRef, Variable
 
+if TYPE_CHECKING:
+    from rdflib.paths import Path
+
 _Triple = Tuple[Identifier, Identifier, Identifier]
 
 

rdflib/plugins/sparql/evalutils.py

@@ -28,10 +28,12 @@
 if TYPE_CHECKING:
     from .sparql import _ContextType
 
-FrozenDictT = TypeVar("FrozenDictT", bound=FrozenDict)
+_FrozenDictT = TypeVar("_FrozenDictT", bound=FrozenDict)
 
 
-def _diff(a: Iterable[FrozenDictT], b: Iterable[FrozenDictT], expr) -> Set[FrozenDictT]:
+def _diff(
+    a: Iterable[_FrozenDictT], b: Iterable[_FrozenDictT], expr
+) -> Set[_FrozenDictT]:
     res = set()
 
     for x in a:
@@ -42,8 +44,8 @@ def _diff(a: Iterable[FrozenDictT], b: Iterable[FrozenDictT], expr) -> Set[Froze
 
 
 def _minus(
-    a: Iterable[FrozenDictT], b: Iterable[FrozenDictT]
-) -> Generator[FrozenDictT, None, None]:
+    a: Iterable[_FrozenDictT], b: Iterable[_FrozenDictT]
+) -> Generator[_FrozenDictT, None, None]:
     for x in a:
         if all((not x.compatible(y)) or x.disjointDomain(y) for y in b):
             yield x
@@ -177,31 +179,9 @@ def _fillTemplate(
             yield (_s, _p, _o)
 
 
-# @overload
-# def _val(v: Variable) -> Tuple[int, Variable]:
-#     ...
-
-
-# @overload
-# def _val(v: BNode) -> Tuple[int, BNode]:
-#     ...
-
-
-# @overload
-# def _val(v: URIRef) -> Tuple[int, URIRef]:
-#     ...
-
-
-# @overload
-# def _val(v: Literal) -> Tuple[int, Literal]:
-#     ...
-
 _ValueT = TypeVar("_ValueT", Variable, BNode, URIRef, Literal)
 
 
-# def _val(
-#     v: Union[Variable, BNode, URIRef, Literal]
-# ) -> Tuple[int, Union[Variable, BNode, URIRef, Literal]]:
 def _val(v: _ValueT) -> Tuple[int, _ValueT]:
     """utilitity for ordering things"""
     if isinstance(v, Variable):

rdflib/plugins/sparql/sparql.py

@@ -462,18 +462,3 @@ def __init__(self, prologue: Prologue, algebra: List[CompValue]):
         self.prologue = prologue
         self.algebra = algebra
         self._original_args: Tuple[str, Mapping[str, str], Optional[str]]
-
-
-__all__ = [
-    "SPARQLError",
-    "NotBoundError",
-    "AlreadyBound",
-    "SPARQLTypeError",
-    "Bindings",
-    "FrozenDict",
-    "FrozenBindings",
-    "QueryContext",
-    "Prologue",
-    "Query",
-    "Update",
-]

rdflib/term.py

@@ -1,5 +1,3 @@
-from __future__ import annotations
-
 """
 This module defines the different types of terms. Terms are the kinds of
 objects that can appear in a quoted/asserted triple. This includes those

rdflib/void.py

@@ -1,10 +1,7 @@
-from __future__ import annotations
-
 import collections
 
-from rdflib.graph import Graph
+from rdflib import Graph, Literal, URIRef
 from rdflib.namespace import RDF, VOID
-from rdflib.term import Literal, URIRef
 
 
 def generateVoID(  # noqa: N802