iwana-20220126T2212-typing: checkpoint 20230908T003652 - SQ

[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.

Author: aucampia

docs/conf.py

@@ -285,7 +285,6 @@ def find_version(filename):
     ("py:class", "pyparsing.core.ParserElement"),
 ]
 
-
 def autodoc_skip_member_handler(
     app: sphinx.application.Sphinx,
     what: str,

examples/resource_example.py

@@ -25,7 +25,8 @@
     bill.add(RDF.type, FOAF.Agent)
     bill.set(RDFS.label, Literal("Bill"))
 
-    bill.add(FOAF.knows, bob)
+    # type error: Argument 2 to "add" of "Resource" has incompatible type "Resource"; expected "Node"  [arg-type]
+    bill.add(FOAF.knows, bob)  # type: ignore[arg-type]
 
     # Resources returned when querying are 'auto-boxed' as resources:
     print(f"Bill knows: {bill.value(FOAF.knows).value(FOAF.name)}")

pyproject.toml

@@ -255,6 +255,11 @@ no_implicit_optional = false
 implicit_reexport = false
 
 
+[[tool.mypy.overrides]]
+module = "rdflib.*"
+check_untyped_defs = true
+
+
 [tool.coverage.run]
 branch = true
 source = ["rdflib"]

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

@@ -242,7 +242,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))
 
@@ -257,7 +257,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
@@ -20,7 +22,8 @@ def ascii(stream):
 
 
 def bopen(*args, **kwargs):
-    return open(*args, mode="rb", **kwargs)
+    # type error: No overload variant of "open" matches argument types "Tuple[Any, ...]", "str", "Dict[str, Any]"
+    return open(*args, mode="rb", **kwargs)  # type: ignore[call-overload]
 
 
 long_type = int

rdflib/events.py

@@ -25,7 +25,10 @@
 
 from __future__ import annotations
 
-from typing import Any, Dict, Optional
+from typing import TYPE_CHECKING, Any, Dict, Optional
+
+if TYPE_CHECKING:
+    import typing_extensions as te
 
 __all__ = ["Event", "Dispatcher"]
 
@@ -59,7 +62,7 @@ class Dispatcher:
 
     _dispatch_map: Optional[Dict[Any, Any]] = None
 
-    def set_map(self, amap: Dict[Any, Any]):
+    def set_map(self, amap: Dict[Any, Any]) -> te.Self:
         self._dispatch_map = amap
         return self
 
@@ -72,12 +75,14 @@ def subscribe(self, event_type, handler):
         """
         if self._dispatch_map is None:
             self.set_map({})
-        lst = self._dispatch_map.get(event_type, None)
+        # type error: error: Item "None" of "Optional[Dict[Any, Any]]" has no attribute "get"
+        lst = self._dispatch_map.get(event_type, None)  # type: ignore[union-attr]
         if lst is None:
             lst = [handler]
         else:
             lst.append(handler)
-        self._dispatch_map[event_type] = lst
+        # type error: Unsupported target for indexed assignment ("Optional[Dict[Any, Any]]")
+        self._dispatch_map[event_type] = lst  # type: ignore[index]
         return self
 
     def dispatch(self, event):

rdflib/plugins/parsers/jsonld.py

@@ -122,7 +122,13 @@ def to_rdf(
     data: Any,
     dataset: Graph,
     base: Optional[str] = None,
-    context_data: Optional[bool] = None,
+    context_data: Optional[
+        Union[
+            List[Union[Dict[str, Any], str, None]],
+            Dict[str, Any],
+            str,
+        ]
+    ] = None,
     version: Optional[float] = None,
     generalized_rdf: bool = False,
     allow_lists_of_lists: Optional[bool] = None,

rdflib/plugins/parsers/rdfxml.py

@@ -87,12 +87,14 @@ class BagID(URIRef):
     __slots__ = ["li"]
 
     def __init__(self, val):
-        super(URIRef, self).__init__(val)
+        # type error: Too many arguments for "__init__" of "object"
+        super(URIRef, self).__init__(val)  # type: ignore[call-arg]
         self.li = 0
 
     def next_li(self):
         self.li += 1
-        return RDFNS["_%s" % self.li]
+        # type error: Type expected within [...]
+        return RDFNS["_%s" % self.li]  # type: ignore[misc]
 
 
 class ElementHandler:

rdflib/plugins/serializers/jsonld.py

@@ -37,17 +37,20 @@
 from __future__ import annotations
 
 import warnings
-from typing import IO, Optional
+from typing import IO, TYPE_CHECKING, Any, Dict, List, Optional
 
 from rdflib.graph import Graph
 from rdflib.namespace import RDF, XSD
 from rdflib.serializer import Serializer
-from rdflib.term import BNode, Literal, URIRef
+from rdflib.term import BNode, IdentifiedNode, Identifier, Literal, URIRef
 
 from ..shared.jsonld.context import UNDEF, Context
 from ..shared.jsonld.keys import CONTEXT, GRAPH, ID, LANG, LIST, SET, VOCAB
 from ..shared.jsonld.util import json
 
+if TYPE_CHECKING:
+    pass
+
 __all__ = ["JsonLDSerializer", "from_rdf"]
 
 
@@ -140,12 +143,12 @@ def from_rdf(
 
 
 class Converter:
-    def __init__(self, context, use_native_types, use_rdf_type):
+    def __init__(self, context: Context, use_native_types: bool, use_rdf_type: bool):
         self.context = context
         self.use_native_types = context.active or use_native_types
         self.use_rdf_type = use_rdf_type
 
-    def convert(self, graph):
+    def convert(self, graph: Graph):
         # TODO: bug in rdflib dataset parsing (nquads et al):
         # plain triples end up in separate unnamed graphs (rdflib issue #436)
         if graph.context_aware:
@@ -161,7 +164,7 @@ def convert(self, graph):
 
         context = self.context
 
-        objs = []
+        objs: List[Any] = []
         for g in graphs:
             obj = {}
             graphname = None
@@ -194,8 +197,8 @@ def convert(self, graph):
 
         return objs
 
-    def from_graph(self, graph):
-        nodemap = {}
+    def from_graph(self, graph: Graph):
+        nodemap: Dict[Any, Any] = {}
 
         for s in set(graph.subjects()):
             ## only iri:s and unreferenced (rest will be promoted to top if needed)
@@ -206,12 +209,13 @@ def from_graph(self, graph):
 
         return list(nodemap.values())
 
-    def process_subject(self, graph, s, nodemap):
+    def process_subject(self, graph: Graph, s: IdentifiedNode, nodemap):
         if isinstance(s, URIRef):
             node_id = self.context.shrink_iri(s)
         elif isinstance(s, BNode):
             node_id = s.n3()
         else:
+            # This does not seem right, this probably should be an error.
             node_id = None
 
         # used_as_object = any(graph.subjects(None, s))
@@ -227,7 +231,15 @@ def process_subject(self, graph, s, nodemap):
 
         return node
 
-    def add_to_node(self, graph, s, p, o, s_node, nodemap):
+    def add_to_node(
+        self,
+        graph: Graph,
+        s: IdentifiedNode,
+        p: IdentifiedNode,
+        o: Identifier,
+        s_node: Dict[str, Any],
+        nodemap,
+    ):
         context = self.context
 
         if isinstance(o, Literal):
@@ -302,7 +314,7 @@ def add_to_node(self, graph, s, p, o, s_node, nodemap):
             value = node
         s_node[p_key] = value
 
-    def type_coerce(self, o, coerce_type):
+    def type_coerce(self, o: IdentifiedNode, coerce_type: str):
         if coerce_type == ID:
             if isinstance(o, URIRef):
                 return self.context.shrink_iri(o)
@@ -317,7 +329,9 @@ def type_coerce(self, o, coerce_type):
         else:
             return None
 
-    def to_raw_value(self, graph, s, o, nodemap):
+    def to_raw_value(
+        self, graph: Graph, s: IdentifiedNode, o: Identifier, nodemap: Dict[str, Any]
+    ):
         context = self.context
         coll = self.to_collection(graph, o)
         if coll is not None:
@@ -364,7 +378,7 @@ def to_raw_value(self, graph, s, o, nodemap):
             else:
                 return v
 
-    def to_collection(self, graph, l_):
+    def to_collection(self, graph: Graph, l_: Identifier):
         if l_ != RDF.nil and not graph.value(l_, RDF.first):
             return None
         list_nodes = []