Strict typing (#138)

Co-authored-by: J. Nick Koston <[email protected]>

Author: Dreamsorcerer

.github/workflows/ci.yml

@@ -30,7 +30,7 @@ jobs:
       run: |
         pip install .
     - name: Run mypy
-      run: python mypy_run.py
+      run: mypy
     - name: Prepare twine checker
       run: |
         pip install -U build twine wheel

.mypy.ini

@@ -0,0 +1,28 @@
+[mypy]
+files = aiodns, tests
+check_untyped_defs = True
+follow_imports_for_stubs = True
+disallow_any_decorated = True
+disallow_any_generics = True
+disallow_any_unimported = True
+disallow_incomplete_defs = True
+disallow_subclassing_any = True
+disallow_untyped_calls = True
+disallow_untyped_decorators = True
+disallow_untyped_defs = True
+# TODO(PY312): explicit-override
+enable_error_code = deprecated, ignore-without-code, possibly-undefined, redundant-expr, redundant-self, truthy-bool, truthy-iterable, unused-awaitable
+extra_checks = True
+follow_untyped_imports = True
+implicit_reexport = False
+no_implicit_optional = True
+pretty = True
+show_column_numbers = True
+show_error_codes = True
+show_error_code_links = True
+strict_equality = True
+warn_incomplete_stub = True
+warn_redundant_casts = True
+warn_return_any = True
+warn_unreachable = True
+warn_unused_ignores = True

aiodns/__init__.py

@@ -1,10 +1,11 @@
-
 import asyncio
 import functools
-import pycares
 import socket
 import sys
+from collections.abc import Iterable, Sequence
+from typing import Any, Literal, Optional, TypeVar, Union, overload
 
+import pycares
 from typing import (
     Any,
     Callable,
@@ -22,6 +23,8 @@
 
 __all__ = ('DNSResolver', 'error')
 
+_T = TypeVar("_T")
+
 WINDOWS_SELECTOR_ERR_MSG = (
     "aiodns needs a SelectorEventLoop on Windows. See more: "
     "https://github.com/aio-libs/aiodns#note-for-windows-users"
@@ -55,7 +58,7 @@
 class DNSResolver:
     def __init__(self, nameservers: Optional[Sequence[str]] = None,
                  loop: Optional[asyncio.AbstractEventLoop] = None,
-                 **kwargs: Any) -> None:
+                 **kwargs: Any) -> None:  # TODO(PY311): Use Unpack for kwargs.
         self.loop = loop or asyncio.get_event_loop()
         assert self.loop is not None
         kwargs.pop('sock_state_cb', None)
@@ -80,31 +83,33 @@ def __init__(self, nameservers: Optional[Sequence[str]] = None,
                                             **kwargs)
         if nameservers:
             self.nameservers = nameservers
-        self._read_fds = set() # type: Set[int]
-        self._write_fds = set() # type: Set[int]
-        self._timer = None  # type: Optional[asyncio.TimerHandle]
+        self._read_fds: set[int] = set()
+        self._write_fds: set[int] = set()
+        self._timer: Optional[asyncio.TimerHandle] = None
 
     @property
     def nameservers(self) -> Sequence[str]:
         return self._channel.servers
 
     @nameservers.setter
-    def nameservers(self, value: Sequence[str]) -> None:
-        self._channel.servers = value if isinstance(value, list) else list(value)
+    def nameservers(self, value: Iterable[Union[str, bytes]]) -> None:
+        # Remove type ignore after mypy 1.16.0
+        # https://github.com/python/mypy/issues/12892
+        self._channel.servers = value  # type: ignore[assignment]
 
     @staticmethod
-    def _callback(fut: asyncio.Future, result: Any, errorno: int) -> None:
+    def _callback(fut: asyncio.Future[_T], result: _T, errorno: Optional[int]) -> None:
         if fut.cancelled():
             return
         if errorno is not None:
             fut.set_exception(error.DNSError(errorno, pycares.errno.strerror(errorno)))
         else:
             fut.set_result(result)
 
-    def _get_future_callback(self) -> Tuple["asyncio.Future[Any]", Callable[[Any, int], None]]:
+    def _get_future_callback(self) -> Tuple["asyncio.Future[_T]", Callable[[_T, int], None]]:
         """Return a future and a callback to set the result of the future."""
-        cb: Callable[[Any, int], None]
-        future: "asyncio.Future[Any]" = self.loop.create_future()
+        cb: Callable[[_T, int], None]
+        future: "asyncio.Future[_T]" = self.loop.create_future()
         if self._event_thread:
             cb = functools.partial(  # type: ignore[assignment]
                 self.loop.call_soon_threadsafe,
@@ -115,7 +120,41 @@ def _get_future_callback(self) -> Tuple["asyncio.Future[Any]", Callable[[Any, in
             cb = functools.partial(self._callback, future)
         return future, cb
 
-    def query(self, host: str, qtype: str, qclass: Optional[str]=None) -> asyncio.Future:
+    @overload
+    def query(self, host: str, qtype: Literal["A"], qclass: Optional[str] = ...) -> asyncio.Future[list[pycares.ares_query_a_result]]:
+        ...
+    @overload
+    def query(self, host: str, qtype: Literal["AAAA"], qclass: Optional[str] = ...) -> asyncio.Future[list[pycares.ares_query_aaaa_result]]:
+        ...
+    @overload
+    def query(self, host: str, qtype: Literal["CAA"], qclass: Optional[str] = ...) -> asyncio.Future[list[pycares.ares_query_caa_result]]:
+        ...
+    @overload
+    def query(self, host: str, qtype: Literal["CNAME"], qclass: Optional[str] = ...) -> asyncio.Future[list[pycares.ares_query_cname_result]]:
+        ...
+    @overload
+    def query(self, host: str, qtype: Literal["MX"], qclass: Optional[str] = ...) -> asyncio.Future[list[pycares.ares_query_mx_result]]:
+        ...
+    @overload
+    def query(self, host: str, qtype: Literal["NAPTR"], qclass: Optional[str] = ...) -> asyncio.Future[list[pycares.ares_query_naptr_result]]:
+        ...
+    @overload
+    def query(self, host: str, qtype: Literal["NS"], qclass: Optional[str] = ...) -> asyncio.Future[list[pycares.ares_query_ns_result]]:
+        ...
+    @overload
+    def query(self, host: str, qtype: Literal["PTR"], qclass: Optional[str] = ...) -> asyncio.Future[list[pycares.ares_query_ptr_result]]:
+        ...
+    @overload
+    def query(self, host: str, qtype: Literal["SOA"], qclass: Optional[str] = ...) -> asyncio.Future[list[pycares.ares_query_soa_result]]:
+        ...
+    @overload
+    def query(self, host: str, qtype: Literal["SRV"], qclass: Optional[str] = ...) -> asyncio.Future[list[pycares.ares_query_srv_result]]:
+        ...
+    @overload
+    def query(self, host: str, qtype: Literal["TXT"], qclass: Optional[str] = ...) -> asyncio.Future[list[pycares.ares_query_txt_result]]:
+        ...
+
+    def query(self, host: str, qtype: str, qclass: Optional[str]=None) -> asyncio.Future[list[Any]]:
         try:
             qtype = query_type_map[qtype]
         except KeyError:
@@ -126,30 +165,35 @@ def query(self, host: str, qtype: str, qclass: Optional[str]=None) -> asyncio.Fu
             except KeyError:
                 raise ValueError('invalid query class: {}'.format(qclass))
 
+        fut: asyncio.Future[list[Any]]
         fut, cb = self._get_future_callback()
         self._channel.query(host, qtype, cb, query_class=qclass)
         return fut
 
-    def gethostbyname(self, host: str, family: socket.AddressFamily) -> asyncio.Future:
+    def gethostbyname(self, host: str, family: socket.AddressFamily) -> asyncio.Future[pycares.ares_host_result]:
+        fut: asyncio.Future[pycares.ares_host_result]
         fut, cb = self._get_future_callback()
         self._channel.gethostbyname(host, family, cb)
         return fut
 
-    def getaddrinfo(self, host: str, family: socket.AddressFamily = socket.AF_UNSPEC, port: Optional[int] = None, proto: int = 0, type: int = 0, flags: int = 0) -> asyncio.Future:
+    def getaddrinfo(self, host: str, family: socket.AddressFamily = socket.AF_UNSPEC, port: Optional[int] = None, proto: int = 0, type: int = 0, flags: int = 0) -> asyncio.Future[pycares.ares_addrinfo_result]:
+        fut: asyncio.Future[pycares.ares_addrinfo_result]
         fut, cb = self._get_future_callback()
         self._channel.getaddrinfo(host, port, cb, family=family, type=type, proto=proto, flags=flags)
         return fut
 
-    def getnameinfo(self, sockaddr: Union[Tuple[str, int], Tuple[str, int, int, int]], flags: int = 0) -> asyncio.Future:
+    def getnameinfo(self, sockaddr: Union[tuple[str, int], tuple[str, int, int, int]], flags: int = 0) -> asyncio.Future[pycares.ares_nameinfo_result]:
+        fut: asyncio.Future[pycares.ares_nameinfo_result]
         fut, cb = self._get_future_callback()
         self._channel.getnameinfo(sockaddr, flags, cb)
         return fut
 
-    def gethostbyaddr(self, name: str) -> asyncio.Future:
+    def gethostbyaddr(self, name: str) -> asyncio.Future[pycares.ares_host_result]:
+        fut: asyncio.Future[pycares.ares_host_result]
         fut, cb = self._get_future_callback()
         self._channel.gethostbyaddr(name, cb)
         return fut
-
+   
     def cancel(self) -> None:
         self._channel.cancel()
 
@@ -177,7 +221,7 @@ def _sock_state_cb(self, fd: int, readable: bool, writable: bool) -> None:
                 self._timer.cancel()
                 self._timer = None
 
-    def _handle_event(self, fd: int, event: Any) -> None:
+    def _handle_event(self, fd: int, event: int) -> None:
         read_fd = pycares.ARES_SOCKET_BAD
         write_fd = pycares.ARES_SOCKET_BAD
         if event == READ:
@@ -193,7 +237,7 @@ def _timer_cb(self) -> None:
         else:
             self._timer = None
 
-    def _start_timer(self):
+    def _start_timer(self) -> None:
         timeout = self._timeout
         if timeout is None or timeout < 0 or timeout > 1:
             timeout = 1

aiodns/error.py

@@ -1,10 +1,32 @@
-
-import pycares
-
-for code, name in pycares.errno.errorcode.items():
-    globals()[name] = code
+from pycares.errno import (
+    ARES_SUCCESS as ARES_SUCCESS,
+    ARES_ENODATA as ARES_ENODATA,
+    ARES_EFORMERR as ARES_EFORMERR,
+    ARES_ESERVFAIL as ARES_ESERVFAIL,
+    ARES_ENOTFOUND as ARES_ENOTFOUND,
+    ARES_ENOTIMP as ARES_ENOTIMP,
+    ARES_EREFUSED as ARES_EREFUSED,
+    ARES_EBADQUERY as ARES_EBADQUERY,
+    ARES_EBADNAME as ARES_EBADNAME,
+    ARES_EBADFAMILY as ARES_EBADFAMILY,
+    ARES_EBADRESP as ARES_EBADRESP,
+    ARES_ECONNREFUSED as ARES_ECONNREFUSED,
+    ARES_ETIMEOUT as ARES_ETIMEOUT,
+    ARES_EOF as ARES_EOF,
+    ARES_EFILE as ARES_EFILE,
+    ARES_ENOMEM as ARES_ENOMEM,
+    ARES_EDESTRUCTION as ARES_EDESTRUCTION,
+    ARES_EBADSTR as ARES_EBADSTR,
+    ARES_EBADFLAGS as ARES_EBADFLAGS,
+    ARES_ENONAME as ARES_ENONAME,
+    ARES_EBADHINTS as ARES_EBADHINTS,
+    ARES_ENOTINITIALIZED as ARES_ENOTINITIALIZED,
+    ARES_ELOADIPHLPAPI as ARES_ELOADIPHLPAPI,
+    ARES_EADDRGETNETWORKPARAMS as ARES_EADDRGETNETWORKPARAMS,
+    ARES_ECANCELLED as ARES_ECANCELLED,
+    ARES_ESERVICE as ARES_ESERVICE
+)
 
 
 class DNSError(Exception):
     pass
-