iwana-20220126T2212-typing: checkpoint 20230910T155719

Author: aucampia

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

rdflib/plugins/serializers/jsonld.py

@@ -39,7 +39,7 @@
 import warnings
 from typing import IO, TYPE_CHECKING, Any, Dict, List, Optional
 
-from rdflib.graph import Graph
+from rdflib.graph import Graph, _ObjectType
 from rdflib.namespace import RDF, XSD
 from rdflib.serializer import Serializer
 from rdflib.term import BNode, IdentifiedNode, Identifier, Literal, URIRef
@@ -154,7 +154,8 @@ def convert(self, graph: Graph):
         if graph.context_aware:
             default_graph = Graph()
             graphs = [default_graph]
-            for g in graph.contexts():
+            # type error: "Graph" has no attribute "contexts"
+            for g in graph.contexts():  # type: ignore[attr-defined]
                 if isinstance(g.identifier, URIRef):
                     graphs.append(g)
                 else:
@@ -227,7 +228,9 @@ def process_subject(self, graph: Graph, s: IdentifiedNode, nodemap):
         nodemap[node_id] = node
 
         for p, o in graph.predicate_objects(s):
-            self.add_to_node(graph, s, p, o, node, nodemap)
+            # type error: Argument 3 to "add_to_node" of "Converter" has incompatible type "Node"; expected "IdentifiedNode"
+            # type error: Argument 4 to "add_to_node" of "Converter" has incompatible type "Node"; expected "Identifier"
+            self.add_to_node(graph, s, p, o, node, nodemap)  # type: ignore[arg-type]
 
         return node
 
@@ -250,7 +253,9 @@ def add_to_node(
             containers = [LIST, None] if graph.value(o, RDF.first) else [None]
             for container in containers:
                 for coercion in (ID, VOCAB, UNDEF):
-                    term = context.find_term(str(p), coercion, container)
+                    # type error: Argument 2 to "find_term" of "Context" has incompatible type "object"; expected "Union[str, Defined, None]"
+                    # type error: Argument 3 to "find_term" of "Context" has incompatible type "Optional[str]"; expected "Union[Defined, str]"
+                    term = context.find_term(str(p), coercion, container)  # type: ignore[arg-type]
                     if term:
                         break
                 if term:
@@ -264,10 +269,12 @@ def add_to_node(
 
             if term.type:
                 node = self.type_coerce(o, term.type)
-            elif term.language and o.language == term.language:
-                node = str(o)
-            elif context.language and (term.language is None and o.language is None):
+            # type error: "Identifier" has no attribute "language"
+            elif term.language and o.language == term.language:  # type: ignore[attr-defined]
                 node = str(o)
+            # type error: Right operand of "and" is never evaluated
+            elif context.language and (term.language is None and o.language is None):  # type: ignore[unreachable]
+                node = str(o)  # type: ignore[unreachable]
 
             if LIST in term.container:
                 node = [
@@ -314,7 +321,7 @@ def add_to_node(
             value = node
         s_node[p_key] = value
 
-    def type_coerce(self, o: IdentifiedNode, coerce_type: str):
+    def type_coerce(self, o: Identifier, coerce_type: str):
         if coerce_type == ID:
             if isinstance(o, URIRef):
                 return self.context.shrink_iri(o)
@@ -373,15 +380,16 @@ def to_raw_value(
                 }
             elif o.language and o.language != context.language:
                 return {context.lang_key: o.language, context.value_key: v}
-            elif not context.active or context.language and not o.language:
+            # type error: Right operand of "and" is never evaluated
+            elif not context.active or context.language and not o.language:  # type: ignore[unreachable]
                 return {context.value_key: v}
             else:
                 return v
 
     def to_collection(self, graph: Graph, l_: Identifier):
         if l_ != RDF.nil and not graph.value(l_, RDF.first):
             return None
-        list_nodes = []
+        list_nodes: List[Optional[_ObjectType]] = []
         chain = set([l_])
         while l_:
             if l_ == RDF.nil:
@@ -397,7 +405,8 @@ def to_collection(self, graph: Graph, l_: Identifier):
                 elif p != RDF.type or o != RDF.List:
                     return None
             list_nodes.append(first)
-            l_ = rest
+            # type error: Incompatible types in assignment (expression has type "Optional[Node]", variable has type "Identifier")
+            l_ = rest  # type: ignore[assignment]
             if l_ in chain:
                 return None
             chain.add(l_)

rdflib/plugins/sparql/aggregates.py

@@ -227,7 +227,8 @@ class Sample(Accumulator):
     def __init__(self, aggregation):
         super(Sample, self).__init__(aggregation)
         # DISTINCT would not change the value
-        self.use_row = self.dont_care
+        # type error: Cannot assign to a method
+        self.use_row = self.dont_care  # type: ignore[method-assign]
 
     def update(self, row: FrozenBindings, aggregator: Aggregator) -> None:
         try:

rdflib/resource.py

@@ -341,7 +341,7 @@ def __le__(self, other: object) -> bool:
     def __ge__(self, other: object) -> bool:
         return not self < other
 
-    def __unicode__(self):
+    def __unicode__(self) -> str:
         return str(self._identifier)
 
     def add(self, p: _PredicateType, o: _ObjectType):
@@ -352,13 +352,13 @@ def add(self, p: _PredicateType, o: _ObjectType):
 
     def remove(
         self, p: _PredicateType, o: Optional[Union[_ObjectType, Resource]] = None
-    ):
+    ) -> None:
         if isinstance(o, Resource):
             o = o._identifier
 
         self._graph.remove((self._identifier, p, o))
 
-    def set(self, p: _PredicateType, o: _ObjectType):
+    def set(self, p: _PredicateType, o: _ObjectType) -> None:
         if isinstance(o, Resource):
             o = o._identifier
 
@@ -405,7 +405,8 @@ def transitive_subjects(self, predicate, remember=None):
         )
 
     def qname(self):
-        return self._graph.qname(self._identifier)
+        # type error: Argument 1 to "qname" of "Graph" has incompatible type "Node"; expected "str"
+        return self._graph.qname(self._identifier)  # type: ignore[arg-type]
 
     def _resource_pairs(self, pairs):
         for s1, s2 in pairs:
@@ -458,7 +459,8 @@ def __getitem__(self, item):
             else:
                 return (self.identifier, p, o) in self._graph
         elif isinstance(item, (Node, Path)):
-            return self.objects(item)
+            # type error: Argument 1 to "objects" of "Resource" has incompatible type "Union[Node, Path]"; expected "Optional[Node]"
+            return self.objects(item)  # type: ignore[arg-type]
         else:
             raise TypeError(
                 "You can only index a resource by a single rdflib term, a slice of rdflib terms, not %s (%s)"