[DO NOT REVIEW] Add a bunch of typing

This is a branch I'm maintaing with a bunch of typing, I'm planning to
integrate it with master in parts, anyone is welcome to have a look but
most of what is happening here is subject to change.

checkpoint

checkpoint

Author: aucampia

docs/conf.py

@@ -323,6 +323,9 @@ def find_version(filename):
             ("py:class", "_TripleOrTriplePathType"),
             ("py:class", "TextIO"),
             ("py:class", "Message"),
+            ("py:class", "HTTPResponse"),
+            ("py:class", "HTTPMessage"),
+            ("py:class", "EntryPoint"),
         ]
     )
 

rdflib/_typing.py

@@ -0,0 +1,23 @@
+# import sys
+# from typing import TYPE_CHECKING, Optional, Tuple, TypeVar
+
+# if sys.version_info >= (3, 10):
+#     from typing import TypeAlias
+# else:
+#     from typing_extensions import TypeAlias
+
+# if TYPE_CHECKING:
+#     from rdflib.graph import Graph
+#     from rdflib.term import IdentifiedNode, Identifier
+
+# _SubjectType: TypeAlias = "IdentifiedNode"
+# _PredicateType: TypeAlias = "IdentifiedNode"
+# _ObjectType: TypeAlias = "Identifier"
+
+# _TripleType = Tuple["_SubjectType", "_PredicateType", "_ObjectType"]
+# _QuadType = Tuple["_SubjectType", "_PredicateType", "_ObjectType", "Graph"]
+# _TriplePatternType = Tuple[
+#     Optional["_SubjectType"], Optional["_PredicateType"], Optional["_ObjectType"]
+# ]
+
+# _GraphT = TypeVar("_GraphT", bound="Graph")

rdflib/collection.py

@@ -243,7 +243,7 @@ def append(self, item: Node) -> Collection:
         self.graph.add((end, RDF.rest, RDF.nil))
         return self
 
-    def __iadd__(self, other: Iterable[Node]):
+    def __iadd__(self, other: Iterable[Node]) -> Collection:
         end = self._end()
         self.graph.remove((end, RDF.rest, None))
 
@@ -258,7 +258,7 @@ def __iadd__(self, other: Iterable[Node]):
         self.graph.add((end, RDF.rest, RDF.nil))
         return self
 
-    def clear(self):
+    def clear(self) -> Collection:
         container: Optional[Node] = self.uri
         graph = self.graph
         while container:

rdflib/compat.py

@@ -3,6 +3,8 @@
 and different versions of support libraries.
 """
 
+from __future__ import annotations
+
 import codecs
 import re
 import warnings
@@ -101,6 +103,6 @@ def decodeUnicodeEscape(escaped: str) -> str:
 
 # Migration to abc in Python 3.8
 try:
-    from collections.abc import Mapping, MutableMapping
+    from collections.abc import Mapping, MutableMapping  # noqa: F401
 except:
-    from collections import Mapping, MutableMapping
+    pass

rdflib/extras/infixowl.py

@@ -110,11 +110,10 @@
 import itertools
 import logging
 
-from rdflib import OWL, RDF, RDFS, XSD, BNode, Literal, Namespace, URIRef, Variable
 from rdflib.collection import Collection
 from rdflib.graph import Graph
-from rdflib.namespace import NamespaceManager
-from rdflib.term import Identifier
+from rdflib.namespace import OWL, RDF, RDFS, XSD, Namespace, NamespaceManager
+from rdflib.term import BNode, Identifier, Literal, URIRef, Variable
 from rdflib.util import first
 
 logger = logging.getLogger(__name__)

rdflib/namespace/__init__.py

@@ -1,6 +1,4 @@
-import json
 import logging
-import sys
 import warnings
 from functools import lru_cache
 from pathlib import Path

rdflib/plugins/serializers/rdfxml.py

@@ -1,5 +1,5 @@
 import xml.dom.minidom
-from typing import IO, Dict, Optional, Set
+from typing import IO, Dict, Generator, Optional, Set, Tuple
 from xml.sax.saxutils import escape, quoteattr
 
 from rdflib.collection import Collection
@@ -20,13 +20,14 @@ class XMLSerializer(Serializer):
     def __init__(self, store: Graph):
         super(XMLSerializer, self).__init__(store)
 
-    def __bindings(self):
+    def __bindings(self) -> Generator[Tuple[str, URIRef], None, None]:
         store = self.store
         nm = store.namespace_manager
-        bindings = {}
+        bindings: Dict[str, URIRef] = {}
 
         for predicate in set(store.predicates()):
-            prefix, namespace, name = nm.compute_qname_strict(predicate)
+            # type error: Argument 1 to "compute_qname_strict" of "NamespaceManager" has incompatible type "Node"; expected "str"
+            prefix, namespace, name = nm.compute_qname_strict(predicate)  # type: ignore[arg-type]
             bindings[prefix] = URIRef(namespace)
 
         RDFNS = URIRef("http://www.w3.org/1999/02/22-rdf-syntax-ns#")
@@ -45,7 +46,7 @@ def serialize(
         base: Optional[str] = None,
         encoding: Optional[str] = None,
         **args,
-    ):
+    ) -> None:
         # if base is given here, use that, if not and a base is set for the graph use that
         if base is not None:
             self.base = base
@@ -82,7 +83,8 @@ def serialize(
 
         # write out triples by subject
         for subject in self.store.subjects():
-            self.subject(subject, 1)
+            # type error: Argument 1 to "subject" of "XMLSerializer" has incompatible type "Node"; expected "Identifier"
+            self.subject(subject, 1)  # type: ignore[arg-type]
 
         # endRDF
         write("</rdf:RDF>\n")
@@ -91,7 +93,7 @@ def serialize(
         # self.__serialized = None
         del self.__serialized
 
-    def subject(self, subject, depth=1):
+    def subject(self, subject: Identifier, depth: int = 1) -> None:
         if subject not in self.__serialized:
             self.__serialized[subject] = 1
 
@@ -110,13 +112,17 @@ def subject(self, subject, depth=1):
                     write(">\n")
 
                     for predicate, object in self.store.predicate_objects(subject):
-                        self.predicate(predicate, object, depth + 1)
+                        # type error: Argument 1 to "predicate" of "XMLSerializer" has incompatible type "Node"; expected "Identifier"
+                        # type error: Argument 2 to "predicate" of "XMLSerializer" has incompatible type "Node"; expected "Identifier"
+                        self.predicate(predicate, object, depth + 1)  # type: ignore[arg-type]
                     write("%s</%s>\n" % (indent, element_name))
 
                 else:
                     write("/>\n")
 
-    def predicate(self, predicate, object, depth=1):
+    def predicate(
+        self, predicate: Identifier, object: Identifier, depth: int = 1
+    ) -> None:
         write = self.write
         indent = "  " * depth
         qname = self.store.namespace_manager.qname_strict(predicate)
@@ -150,7 +156,7 @@ def predicate(self, predicate, object, depth=1):
 
 
 # TODO:
-def fix(val):
+def fix(val: str) -> str:
     "strip off _: from nodeIDs... as they are not valid NCNames"
     if val.startswith("_:"):
         return val[2:]
@@ -169,7 +175,7 @@ def serialize(
         base: Optional[str] = None,
         encoding: Optional[str] = None,
         **args,
-    ):
+    ) -> None:
         self.__serialized: Dict[Identifier, int] = {}
         store = self.store
         # if base is given here, use that, if not and a base is set for the graph use that
@@ -236,7 +242,7 @@ def serialize(
         # Set to None so that the memory can get garbage collected.
         self.__serialized = None  # type: ignore[assignment]
 
-    def subject(self, subject: IdentifiedNode, depth: int = 1):
+    def subject(self, subject: Identifier, depth: int = 1):
         store = self.store
         writer = self.writer
 
@@ -257,7 +263,8 @@ def subject(self, subject: IdentifiedNode, depth: int = 1):
                 type = None
 
             element = type or RDFVOC.Description
-            writer.push(element)
+            # type error: Argument 1 to "push" of "XMLWriter" has incompatible type "Node"; expected "str"
+            writer.push(element)  # type: ignore[arg-type]
 
             if isinstance(subject, BNode):
 
@@ -277,9 +284,12 @@ def subj_as_obj_more_than(ceil):
             if (subject, None, None) in store:
                 for predicate, object in store.predicate_objects(subject):
                     if not (predicate == RDF.type and object == type):
-                        self.predicate(predicate, object, depth + 1)
+                        # type error: Argument 1 to "predicate" of "PrettyXMLSerializer" has incompatible type "Node"; expected "Identifier"
+                        # type error: Argument 2 to "predicate" of "PrettyXMLSerializer" has incompatible type "Node"; expected "Identifier"
+                        self.predicate(predicate, object, depth + 1)  # type: ignore[arg-type]
 
-            writer.pop(element)
+            # type error: Argument 1 to "pop" of "XMLWriter" has incompatible type "Node"; expected "Optional[str]"
+            writer.pop(element)  # type: ignore[arg-type]
 
         elif subject in self.forceRDFAbout:
             # TODO FIXME?: this looks like a duplicate of first condition
@@ -288,7 +298,9 @@ def subj_as_obj_more_than(ceil):
             writer.pop(RDFVOC.Description)
             self.forceRDFAbout.remove(subject)  # type: ignore[arg-type]
 
-    def predicate(self, predicate, object, depth=1):
+    def predicate(
+        self, predicate: Identifier, object: Identifier, depth: int = 1
+    ) -> None:
         writer = self.writer
         store = self.store
         writer.push(predicate)
@@ -338,14 +350,17 @@ def predicate(self, predicate, object, depth=1):
                 for item in col:
                     if isinstance(item, URIRef):
                         self.forceRDFAbout.add(item)
-                    self.subject(item)
+                    # type error: Argument 1 to "subject" of "PrettyXMLSerializer" has incompatible type "Node"; expected "Identifier"
+                    self.subject(item)  # type: ignore[arg-type]
 
                     if not isinstance(item, URIRef):
-                        self.__serialized[item] = 1
+                        # type error: Invalid index type "Node" for "Dict[Identifier, int]"; expected type "Identifier"
+                        self.__serialized[item] = 1  # type: ignore[index]
             else:
                 if first(
                     store.triples_choices(
-                        (object, RDF.type, [OWL_NS.Class, RDFS.Class])
+                        # type error: Argument 1 to "triples_choices" of "Graph" has incompatible type "Tuple[Identifier, URIRef, List[URIRef]]"; expected "Union[Tuple[List[Node], Node, Node], Tuple[Node, List[Node], Node], Tuple[Node, Node, List[Node]]]"
+                        (object, RDF.type, [OWL_NS.Class, RDFS.Class])  # type: ignore[arg-type]
                     )
                 ) and isinstance(object, URIRef):
                     writer.attribute(RDFVOC.resource, self.relativize(object))

rdflib/plugins/serializers/trig.py

@@ -3,7 +3,7 @@
 See <http://www.w3.org/TR/trig/> for syntax specification.
 """
 
-from typing import IO, TYPE_CHECKING, Dict, List, Optional, Tuple, Union
+from typing import IO, TYPE_CHECKING, Dict, List, Optional, Tuple
 
 from rdflib.graph import ConjunctiveGraph, Graph
 from rdflib.plugins.serializers.turtle import TurtleSerializer
@@ -19,7 +19,7 @@ class TrigSerializer(TurtleSerializer):
     short_name = "trig"
     indentString = 4 * " "
 
-    def __init__(self, store: Union[Graph, ConjunctiveGraph]):
+    def __init__(self, store: Graph):
         self.default_context: Optional[Node]
         if store.context_aware:
             if TYPE_CHECKING: