Improve type annotations (#225)

Author: cthoyt

src/curies/__main__.py

@@ -1,5 +1,3 @@
-# type:ignore
-
 """Command line interface for ``curies``."""
 
 from .cli import main

src/curies/api.py

@@ -82,9 +82,9 @@
 )
 
 
-def _get_field_validator_values(values, key: str):  # type:ignore
+def _get_field_validator_values(values: Any, key: str) -> str:
     """Get the value for the key from a field validator object."""
-    return values.data[key]
+    return cast(str, values.data[key])
 
 
 class ReferenceTuple(NamedTuple):
@@ -172,12 +172,12 @@ def to_pydantic(self, *, name: None = ...) -> Reference: ...
     def to_pydantic(self, *, name: str | None = None) -> Reference | NamedReference:
         """Get a Pydantic model."""
         if name is None:
-            return Reference(prefix=self.prefix, identifier=self.identifier)
+            return Reference(prefix=Prefix(self.prefix), identifier=self.identifier)
         if not name:
             raise ValueError(
                 f"tried to construct a pydantic named reference with a missing name from {self.curie}"
             )
-        return NamedReference(prefix=self.prefix, identifier=self.identifier, name=name)
+        return NamedReference(prefix=Prefix(self.prefix), identifier=self.identifier, name=name)
 
 
 class Prefix(str):
@@ -1327,7 +1327,7 @@ def from_reverse_prefix_map(
         >>> converter = Converter.from_reverse_prefix_map(url)
         >>> "chebi" in converter.prefix_map
         """
-        dd = defaultdict(list)
+        dd: defaultdict[str, list[str]] = defaultdict(list)
         for uri_prefix, prefix in _prepare(reverse_prefix_map).items():
             dd[prefix].append(uri_prefix)
         records = []
@@ -3312,21 +3312,22 @@ def __init__(self, initial_dict: dict[str, Record] | None = None) -> None:
             for key, value in initial_dict.items():
                 self[key] = value
 
-    def __setitem__(self, key: str, value: Record) -> None:
-        self.root._ensure_node(key).value = value
+    def __setitem__(self, key: str, item: Record) -> None:
+        self.root._ensure_node(key).value = item
 
     def parse_uri(self, uri: str) -> ReferenceTuple | None:
         """Parse a URI into a prefix/identifier pair based prefixes in the trie."""
-        node: TrieNode | None = self.root
+        node: TrieNode = self.root
         record: Record | None = self.root.value
         max_non_null_index = -1
         for i, character in enumerate(uri):
-            node = cast(TrieNode, node).children.get(character)
-            if node is None:
+            new_node = node.children.get(character)
+            if new_node is None:
                 break
-            if node.value is not None:
-                record = node.value
+            if new_node.value is not None:
+                record = new_node.value
                 max_non_null_index = i
+            node = new_node
         if record is None:
             return None
         identifier = uri[max_non_null_index + 1 :]

src/curies/cli.py

@@ -100,8 +100,11 @@ def _run_app(app: AppHint, server: str, host: str, port: int) -> None:
 
         uvicorn.run(app, host=host, port=port)
     elif server == "werkzeug":
-        # we ignore the type because at this point, we know the app has to be a flask.Flask
-        app.run(host=host, port=port)  # type:ignore[union-attr]
+        import flask
+
+        if not isinstance(app, flask.Flask):
+            raise NotImplementedError
+        app.run(host=host, port=port)
     elif server == "gunicorn":
         raise NotImplementedError
     else:

src/curies/database.py

@@ -208,7 +208,7 @@ class Record(Base):
 from sqlalchemy.sql.type_api import TypeEngine
 from sqlalchemy.types import JSON, TEXT, TypeDecorator
 
-from curies import Reference
+from curies import Prefix, Reference
 
 __all__ = [
     "SAReferenceListTypeDecorator",
@@ -330,7 +330,7 @@ class _ReferenceAdapter(Reference):
 
     def __init__(self, prefix: str, identifier: str) -> None:
         """Initialize the SQLAlchemy model."""
-        super().__init__(prefix=prefix, identifier=identifier)
+        super().__init__(prefix=Prefix(prefix), identifier=identifier)
 
 
 def get_reference_sa_composite(

src/curies/dataframe.py

@@ -370,7 +370,7 @@ def _get_series(df_or_series: DataframeOrSeries, column: str | int | None = None
             raise TypeError(
                 f"passed series that does not have strings: {df_or_series.dtype=} {type(df_or_series.dtype)=}\n\n{df_or_series}"
             )
-        return df_or_series
+        return df_or_series  # ty:ignore
 
     if column is None:
         raise ValueError("must pass non-none column when using a dataframe directly")

src/curies/discovery.py

@@ -55,21 +55,22 @@
 from collections import defaultdict
 from collections.abc import Iterable, Mapping, Sequence
 from pathlib import PurePath
-from typing import IO, TYPE_CHECKING, Any, Literal, TextIO, Union
+from typing import IO, TYPE_CHECKING, Any, Literal, TextIO
 
 from curies import Converter, Record
 
 if TYPE_CHECKING:
     import rdflib
+    import rdflib.parser
+
+    GraphInput = IO[bytes] | TextIO | rdflib.parser.InputSource | str | bytes | PurePath
 
 __all__ = [
     "discover",
     "discover_from_rdf",
 ]
 
-
 GraphFormats = Literal["turtle", "xml", "n3", "nt", "trix"]
-GraphInput = Union[IO[bytes], TextIO, "rdflib.parser.InputSource", str, bytes, PurePath]
 
 
 def discover_from_rdf(

src/curies/mapping_service/__init__.py

@@ -109,7 +109,7 @@
     get_flask_mapping_app,
     get_flask_mapping_blueprint,
 )
-from .rdflib_custom import MappingServiceSPARQLProcessor  # type:ignore
+from .rdflib_custom import MappingServiceSPARQLProcessor
 
 __all__ = [
     "MappingServiceGraph",

src/curies/mapping_service/api.py

@@ -9,7 +9,7 @@
 from rdflib import OWL, Graph, URIRef
 from rdflib.term import _is_valid_uri
 
-from .rdflib_custom import MappingServiceSPARQLProcessor  # type: ignore
+from .rdflib_custom import MappingServiceSPARQLProcessor
 from .utils import CONTENT_TYPE_TO_RDFLIB_FORMAT, handle_header
 from ..api import Converter
 
@@ -134,7 +134,7 @@ def get_flask_mapping_blueprint(
 
     blueprint = Blueprint("mapping", __name__, **kwargs)
     graph = MappingServiceGraph(converter=converter)
-    processor = MappingServiceSPARQLProcessor(graph=graph)
+    processor = MappingServiceSPARQLProcessor(graph=graph)  # type:ignore[no-untyped-call]
 
     @blueprint.route(route, methods=["GET", "POST"])
     def serve_sparql() -> Response:
@@ -168,7 +168,7 @@ def get_fastapi_router(
 
     api_router = APIRouter(**kwargs)
     graph = MappingServiceGraph(converter=converter)
-    processor = MappingServiceSPARQLProcessor(graph=graph)
+    processor = MappingServiceSPARQLProcessor(graph=graph)  # type:ignore[no-untyped-call]
 
     def _resolve(accept: str, sparql: str) -> Response:
         content_type = handle_header(accept)

src/curies/mapping_service/rdflib_custom.py

@@ -1,15 +1,17 @@
-# type: ignore
-
 """A custom SPARQL processor that optimizes the query based on https://github.com/RDFLib/rdflib/pull/2257."""
 
 from __future__ import annotations
 
+from collections.abc import Mapping
+from typing import Any
+
 from rdflib.plugins.sparql.algebra import translateQuery
 from rdflib.plugins.sparql.evaluate import evalQuery
 from rdflib.plugins.sparql.parser import parseQuery
 from rdflib.plugins.sparql.parserutils import CompValue
 from rdflib.plugins.sparql.processor import SPARQLProcessor
 from rdflib.plugins.sparql.sparql import Query
+from rdflib.term import Identifier
 
 __all__ = ["MappingServiceSPARQLProcessor"]
 
@@ -53,22 +55,22 @@ class MappingServiceSPARQLProcessor(SPARQLProcessor):
     available to the ``triples`` function.
     """
 
-    def query(
+    def query(  # type:ignore[override]
         self,
-        query: str | Query,
-        initBindings=None,  # noqa:N803
-        initNs=None,  # noqa:N803
-        base=None,
-        DEBUG=False,  # noqa:N803
-    ):
+        strOrQuery: str | Query,  # noqa:N803
+        initBindings: Mapping[str, Identifier] | None = None,  # noqa:N803
+        initNs: Mapping[str, Any] | None = None,  # noqa:N803
+        base: str | None = None,
+        DEBUG: bool = False,  # noqa:N803
+    ) -> Mapping[Any, Any]:
         """Evaluate a SPARQL query on this processor's graph."""
-        if isinstance(query, str):
-            parse_tree = parseQuery(query)
-            query = translateQuery(parse_tree, base, initNs)
-            return self.query(query, initBindings=initBindings, base=base)
+        if isinstance(strOrQuery, str):
+            parse_tree = parseQuery(strOrQuery)
+            str_or_qury = translateQuery(parse_tree, base, initNs)
+            return self.query(str_or_qury, initBindings=initBindings, base=base)
 
-        query.algebra = _optimize_node(query.algebra)
-        return evalQuery(self.graph, query, initBindings or {}, base)
+        strOrQuery.algebra = _optimize_node(strOrQuery.algebra)
+        return evalQuery(self.graph, strOrQuery, initBindings or {}, base)
 
 
 # From Jerven's PR to RDFLib (https://github.com/RDFLib/rdflib/pull/2257)

src/curies/mapping_service/utils.py

@@ -148,7 +148,9 @@ def handle_header(header: str | None, default: str = DEFAULT_CONTENT_TYPE) -> st
     return default
 
 
-def require_service(url: str, name: str):  # type:ignore
+def require_service(
+    url: str, name: str
+) -> Callable[[type[unittest.TestCase]], type[unittest.TestCase]]:
     """Skip a test unless the service is available."""
     return unittest.skipUnless(
         sparql_service_available(url), reason=f"No {name} service is running on {url}"