feat: enable check_untyped_defs for Mypy (#2580)

This change enables `check_untyped_defs` so that Mypy will check all
code, even if it is not annotated with type hints.

This change also fixes all errors that were raised after
`check_untyped_defs` was enabled.

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/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

@@ -72,12 +72,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/extras/cmdlineutils.py

@@ -1,7 +1,10 @@
+from __future__ import annotations
+
 import codecs
 import getopt
 import sys
 import time
+from typing import TextIO, Union
 
 import rdflib
 from rdflib.util import guess_format
@@ -40,6 +43,7 @@ def main(target, _help=_help, options="", stdin=True):
     else:
         f = None
 
+    out: Union[TextIO, codecs.StreamReaderWriter]
     if "-o" in dargs:
         sys.stderr.write("Output to %s\n" % dargs["-o"])
         out = codecs.open(dargs["-o"], "w", "utf-8")

rdflib/extras/infixowl.py

@@ -112,12 +112,14 @@
 >>> print(g.serialize(format='pretty-xml'))  # doctest: +SKIP
 
 """
+from __future__ import annotations
 
 import itertools
 import logging
+from typing import Iterable, Union
 
 from rdflib.collection import Collection
-from rdflib.graph import Graph
+from rdflib.graph import Graph, _ObjectType
 from rdflib.namespace import OWL, RDF, RDFS, XSD, Namespace, NamespaceManager
 from rdflib.term import BNode, Identifier, Literal, URIRef, Variable
 from rdflib.util import first
@@ -432,11 +434,11 @@ def replace(self, other):
             self.graph.add((s, p, classOrIdentifier(other)))
         self.delete()
 
-    def _get_type(self):
+    def _get_type(self) -> Iterable[_ObjectType]:
         for _t in self.graph.objects(subject=self.identifier, predicate=RDF.type):
             yield _t
 
-    def _set_type(self, kind):
+    def _set_type(self, kind: Union[Individual, Identifier, Iterable[_ObjectType]]):
         if not kind:
             return
         if isinstance(kind, (Individual, Identifier)):
@@ -462,10 +464,10 @@ def _delete_type(self):
 
     type = property(_get_type, _set_type, _delete_type)
 
-    def _get_identifier(self):
+    def _get_identifier(self) -> Identifier:
         return self.__identifier
 
-    def _set_identifier(self, i):
+    def _set_identifier(self, i: Identifier):
         assert i
         if i != self.__identifier:
             oldstatements_out = [
@@ -492,11 +494,13 @@ def _set_identifier(self, i):
 
     identifier = property(_get_identifier, _set_identifier)
 
-    def _get_sameAs(self):  # noqa: N802
+    def _get_sameAs(self) -> Iterable[_ObjectType]:  # noqa: N802
         for _t in self.graph.objects(subject=self.identifier, predicate=OWL.sameAs):
             yield _t
 
-    def _set_sameAs(self, term):  # noqa: N802
+    def _set_sameAs(  # noqa: N802
+        self, term: Union[Individual, Identifier, Iterable[_ObjectType]]
+    ):
         # if not kind:
         #     return
         if isinstance(term, (Individual, Identifier)):
@@ -1305,7 +1309,8 @@ def isPrimitive(self):  # noqa: N802
         # sc = list(self.subClassOf)
         ec = list(self.equivalentClass)
         for _boolclass, p, rdf_list in self.graph.triples_choices(
-            (self.identifier, [OWL.intersectionOf, OWL.unionOf], None)
+            # type error: Argument 1 to "triples_choices" of "Graph" has incompatible type "Tuple[Any, List[URIRef], None]"; expected "Union[Tuple[List[Node], Node, Node], Tuple[Node, List[Node], Node], Tuple[Node, Node, List[Node]]]"
+            (self.identifier, [OWL.intersectionOf, OWL.unionOf], None)  # type: ignore[arg-type]
         ):
             ec.append(manchesterSyntax(rdf_list, self.graph, boolean=p))
         for _e in ec:
@@ -1331,7 +1336,8 @@ def __repr__(self, full=False, normalization=True):
         sc = list(self.subClassOf)
         ec = list(self.equivalentClass)
         for _boolclass, p, rdf_list in self.graph.triples_choices(
-            (self.identifier, [OWL.intersectionOf, OWL.unionOf], None)
+            # type error: Argument 1 to "triples_choices" of "Graph" has incompatible type "Tuple[Any, List[URIRef], None]"; expected "Union[Tuple[List[Node], Node, Node], Tuple[Node, List[Node], Node], Tuple[Node, Node, List[Node]]]"
+            (self.identifier, [OWL.intersectionOf, OWL.unionOf], None)  # type: ignore[arg-type]
         ):
             ec.append(manchesterSyntax(rdf_list, self.graph, boolean=p))
         dc = list(self.disjointWith)
@@ -1340,7 +1346,9 @@ def __repr__(self, full=False, normalization=True):
             dc.append(c)
         klasskind = ""
         label = list(self.graph.objects(self.identifier, RDFS.label))
-        label = label and "(" + label[0] + ")" or ""
+        # type error: Incompatible types in assignment (expression has type "str", variable has type "List[Node]")
+        # type error: Unsupported operand types for + ("str" and "Node")
+        label = label and "(" + label[0] + ")" or ""  # type: ignore[assignment, operator]
         if sc:
             if full:
                 scjoin = "\n                "
@@ -1421,7 +1429,9 @@ def __init__(self, rdf_list, members=None, graph=None):
             self._rdfList = Collection(
                 self.graph, BNode(), [classOrIdentifier(m) for m in members]
             )
-            self.graph.add((self.identifier, self._operator, self._rdfList.uri))
+            # type error: "OWLRDFListProxy" has no attribute "identifier"
+            # type error: "OWLRDFListProxy" has no attribute "_operator"
+            self.graph.add((self.identifier, self._operator, self._rdfList.uri))  # type: ignore[attr-defined]
 
     def __eq__(self, other):
         """
@@ -1439,7 +1449,8 @@ def __eq__(self, other):
                         return False
                     return True
         else:
-            return self.identifier == other.identifier
+            # type error: "OWLRDFListProxy" has no attribute "identifier"
+            return self.identifier == other.identifier  # type: ignore[attr-defined]
 
     # Redirect python list accessors to the underlying Collection instance
     def __len__(self):
@@ -1777,8 +1788,10 @@ def __init__(
         elif isinstance(restriction_range, Class):
             self.restrictionRange = classOrIdentifier(restriction_range)
         else:
-            self.restrictionRange = first(
-                self.graph.objects(self.identifier, restriction_type)
+            # error: Incompatible types in assignment (expression has type "Optional[Identifier]", variable has type "Identifier")
+            self.restrictionRange = first(  # type: ignore[assignment]
+                # type error: Argument 1 to "first" has incompatible type "Generator[Node, None, None]"; expected "Iterable[Identifier]"
+                self.graph.objects(self.identifier, restriction_type)  # type: ignore[arg-type]
             )
         if (
             self.identifier,
@@ -1834,7 +1847,8 @@ def __eq__(self, other):
         if isinstance(other, Restriction):
             return (
                 other.onProperty == self.onProperty
-                and other.restriction_range == self.restrictionRange
+                # type error: "Restriction" has no attribute "restriction_range"; maybe "restrictionRange"?
+                and other.restriction_range == self.restrictionRange  # type: ignore[attr-defined]
             )
         else:
             return False
@@ -1999,9 +2013,11 @@ def _del_mincardinality(self):
 
     def restrictionKind(self):  # noqa: N802
         for s, p, o in self.graph.triples_choices(
-            (self.identifier, self.restrictionKinds, None)
+            # type error: Argument 1 to "triples_choices" of "Graph" has incompatible type "Tuple[Any, List[URIRef], None]"; expected "Union[Tuple[List[Node], Node, Node], Tuple[Node, List[Node], Node], Tuple[Node, Node, List[Node]]]"
+            (self.identifier, self.restrictionKinds, None)  # type: ignore[arg-type]
         ):
-            return p.split(str(OWL))[-1]
+            # type error: "Node" has no attribute "split"
+            return p.split(str(OWL))[-1]  # type: ignore[attr-defined]
         return None
 
     def __repr__(self):
@@ -2155,9 +2171,11 @@ def __repr__(self):
                 % (self.qname, first(self.comment) and first(self.comment) or "")
             )
             if first(self.inverseOf):
-                two_link_inverse = first(first(self.inverseOf).inverseOf)
+                # type error: Item "None" of "Optional[Any]" has no attribute "inverseOf"
+                two_link_inverse = first(first(self.inverseOf).inverseOf)  # type: ignore[union-attr]
                 if two_link_inverse and two_link_inverse.identifier == self.identifier:
-                    inverserepr = first(self.inverseOf).qname
+                    # type error: Item "None" of "Optional[Any]" has no attribute "qname"
+                    inverserepr = first(self.inverseOf).qname  # type: ignore[union-attr]
                 else:
                     inverserepr = repr(first(self.inverseOf))
                 rt.append(
@@ -2168,7 +2186,8 @@ def __repr__(self):
                     )
                 )
             for _s, _p, roletype in self.graph.triples_choices(
-                (
+                # type error: Argument 1 to "triples_choices" of "Graph" has incompatible type "Tuple[Any, URIRef, List[URIRef]]"; expected "Union[Tuple[List[Node], Node, Node], Tuple[Node, List[Node], Node], Tuple[Node, Node, List[Node]]]"
+                (  # type: ignore[arg-type]
                     self.identifier,
                     RDF.type,
                     [
@@ -2178,7 +2197,8 @@ def __repr__(self):
                     ],
                 )
             ):
-                rt.append(str(roletype.split(str(OWL))[-1]))
+                # type error: "Node" has no attribute "split"
+                rt.append(str(roletype.split(str(OWL))[-1]))  # type: ignore[attr-defined]
         else:
             rt.append(
                 "DatatypeProperty( %s %s"
@@ -2228,7 +2248,8 @@ def canonicalName(term, g):  # noqa: N802
                 ]
             )
         )
-        rt = "\n".join([expr for expr in rt if expr])
+        # type error: Incompatible types in assignment (expression has type "str", variable has type "List[str]")
+        rt = "\n".join([expr for expr in rt if expr])  # type: ignore[assignment]
         rt += "\n)"
         return rt
 

rdflib/graph.py

@@ -655,7 +655,8 @@ def __getitem__(self, item):
                 return (s, p, o) in self
 
         elif isinstance(item, (Path, Node)):
-            return self.predicate_objects(item)
+            # type error: Argument 1 to "predicate_objects" of "Graph" has incompatible type "Union[Path, Node]"; expected "Optional[Node]"
+            return self.predicate_objects(item)  # type: ignore[arg-type]
 
         else:
             raise TypeError(

rdflib/parser.py

@@ -70,7 +70,7 @@ def __init__(self, wrapped: str, encoding="utf-8"):
         super(BytesIOWrapper, self).__init__()
         self.wrapped = wrapped
         self.encoding = encoding
-        self.encoded = None
+        self.encoded: Optional[BytesIO] = None
 
     def read(self, *args, **kwargs):
         if self.encoded is None:
@@ -81,7 +81,8 @@ def read(self, *args, **kwargs):
     def read1(self, *args, **kwargs):
         if self.encoded is None:
             b = codecs.getencoder(self.encoding)(self.wrapped)
-            self.encoded = BytesIO(b)
+            # type error: Argument 1 to "BytesIO" has incompatible type "Tuple[bytes, int]"; expected "Buffer"
+            self.encoded = BytesIO(b)  # type: ignore[arg-type]
         return self.encoded.read1(*args, **kwargs)
 
     def readinto(self, *args, **kwargs):

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/hext.py

@@ -138,6 +138,7 @@ def _context(self, context):
         if context.identifier == "urn:x-rdflib:default":
             return ""
         elif context is not None and self.default_context is not None:
-            if context.identifier == self.default_context.identifier:
+            # type error: "Node" has no attribute "identifier"
+            if context.identifier == self.default_context.identifier:  # type: ignore[attr-defined]
                 return ""
         return context.identifier