Reduce type: ignore from 14 to 5

- store/file.py: handle None payload explicitly, use get_mime_type()
  instead of super().mime_type, narrow LazyHTTPFile.get_data types
- signers.py: normalize privkey to bytes before parsing, use
  cast(bytes, ...) for vendored dkim.sign, rewrite sign methods
  with explicit if/else
- backend/smtp/client.py: add return type annotation for sendmail,
  add from __future__ import annotations
- backend/smtp/backend.py: remove no-any-return ignore (now typed
  via client.py), assert sendmail result is not None
- utils.py: add overloads for to_unicode, use cast(F, wrapper)
  for renderable decorator, build decode_header result with
  explicit loop and assert

Remaining 5 ignores are private API access (msg._headers,
email.utils internals), MIMEMixin inheritance, and a dead
code path in to_unicode.

Author: lavr

emails/backend/smtp/backend.py

@@ -111,7 +111,9 @@ def _send(self, **kwargs: Any) -> SMTPResponse:
                 response.raise_if_needed()
             return response
         else:
-            return client.sendmail(**kwargs)  # type: ignore[no-any-return]
+            result = client.sendmail(**kwargs)
+            assert result is not None  # to_addrs validated by caller
+            return result
 
     def sendmail(self, from_addr: str, to_addrs: str | list[str],
                  msg: Any, mail_options: list[str] | None = None,

emails/backend/smtp/client.py

@@ -1,10 +1,13 @@
 # encoding: utf-8
+from __future__ import annotations
+
 __all__ = ['SMTPClientWithResponse', 'SMTPClientWithResponse_SSL']
 
 import smtplib
-from smtplib import _have_ssl, SMTP
+from smtplib import _have_ssl, SMTP  # noqa: private API
 import logging
-from ... utils import sanitize_email
+from ..response import SMTPResponse
+from ...utils import sanitize_email
 
 logger = logging.getLogger(__name__)
 
@@ -55,7 +58,9 @@ def _rset(self):
         except smtplib.SMTPServerDisconnected:
             pass
 
-    def sendmail(self, from_addr, to_addrs, msg, mail_options=None, rcpt_options=None):
+    def sendmail(self, from_addr: str, to_addrs: list[str] | str,
+                 msg: bytes, mail_options: list[str] | None = None,
+                 rcpt_options: list[str] | None = None) -> SMTPResponse | None:
 
         if not to_addrs:
             return None

emails/signers.py

@@ -4,7 +4,7 @@
 
 import logging
 from email.mime.multipart import MIMEMultipart
-from typing import IO
+from typing import IO, cast
 
 from .packages import dkim
 from .packages.dkim import DKIMException, UnparsableKeyError
@@ -28,13 +28,16 @@ def __init__(self, selector: str, domain: str, key: str | bytes | IO[bytes] | No
         if privkey and hasattr(privkey, 'read'):
             privkey = privkey.read()
 
+        # Normalize to bytes before parsing
+        privkey_bytes = privkey if isinstance(privkey, bytes) else str(privkey).encode()
+
         # Compile private key
         try:
-            privkey = parse_pem_private_key(to_bytes(privkey))  # type: ignore[arg-type]
+            privkey_parsed = parse_pem_private_key(privkey_bytes)
         except UnparsableKeyError as exc:
             raise DKIMException(exc)
 
-        self._sign_params.update({'privkey': privkey,
+        self._sign_params.update({'privkey': privkey_parsed,
                                   'domain': to_bytes(domain),
                                   'selector': to_bytes(selector)})
 
@@ -43,7 +46,7 @@ def get_sign_string(self, message: bytes) -> bytes | None:
             # pydkim module parses message and privkey on each signing
             # this is not optimal for mass operations
             # TODO: patch pydkim or use another signing module
-            return dkim.sign(message=message, **self._sign_params)  # type: ignore[no-any-return]
+            return cast(bytes, dkim.sign(message=message, **self._sign_params))
         except DKIMException:
             if self.ignore_sign_errors:
                 logging.exception('Error signing message')

emails/store/file.py

@@ -144,7 +144,8 @@ def mime(self) -> MIMEBase | None:
         if p is None:
             filename_header = encode_header(self.filename)
             p = MIMEBase(*self.mime_type.split('/', 1), name=filename_header)
-            p.set_payload(to_bytes(self.data))  # type: ignore[arg-type]
+            payload = to_bytes(self.data) or b''
+            p.set_payload(payload)
             encode_base64(p)
             if 'content-disposition' not in self._headers:
                 p.add_header('Content-Disposition', self.content_disposition, filename=filename_header)
@@ -188,7 +189,10 @@ def fetch(self) -> None:
 
     def get_data(self) -> bytes | str:
         self.fetch()
-        return self._data or ''  # type: ignore[return-value]
+        data = self._data
+        if data is None or isinstance(data, (str, bytes)):
+            return data or ''
+        return data.read()
 
     def set_data(self, v: bytes | str | IO[bytes] | None) -> None:
         self._data = v
@@ -198,7 +202,7 @@ def set_data(self, v: bytes | str | IO[bytes] | None) -> None:
     @property
     def mime_type(self) -> str:
         self.fetch()
-        return super(LazyHTTPFile, self).mime_type  # type: ignore[no-any-return]
+        return self.get_mime_type()
 
     @property
     def headers(self) -> dict[str, str]:

emails/utils.py

@@ -10,7 +10,7 @@
 from functools import wraps
 from io import StringIO, BytesIO
 from collections.abc import Callable
-from typing import Any, TypeVar
+from typing import Any, TypeVar, cast, overload
 
 import email.charset
 from email import generator
@@ -33,6 +33,16 @@ def to_native(x: str | bytes | None, charset: str = sys.getdefaultencoding(),
     return x.decode(charset, errors)
 
 
+@overload
+def to_unicode(x: None, charset: str | None = ..., errors: str = ...,
+               allow_none_charset: bool = ...) -> None: ...
+@overload
+def to_unicode(x: str | bytes, charset: str | None = ..., errors: str = ...,
+               allow_none_charset: bool = ...) -> str: ...
+@overload
+def to_unicode(x: Any, charset: str | None = ..., errors: str = ...,
+               allow_none_charset: bool = ...) -> str | None: ...
+
 def to_unicode(x: Any, charset: str | None = sys.getdefaultencoding(),
                errors: str = 'strict',
                allow_none_charset: bool = False) -> str | None:
@@ -41,8 +51,9 @@ def to_unicode(x: Any, charset: str | None = sys.getdefaultencoding(),
     if not isinstance(x, bytes):
         return str(x)
     if charset is None and allow_none_charset:
-        return x  # type: ignore[return-value]  # returns bytes when allow_none_charset=True
-    return x.decode(charset, errors)  # type: ignore[arg-type]  # charset is str here
+        return x  # type: ignore[return-value]  # bytes returned when allow_none_charset=True
+    assert charset is not None  # guaranteed when allow_none_charset is False (default)
+    return x.decode(charset, errors)
 
 
 def to_bytes(x: str | bytes | bytearray | memoryview | None,
@@ -130,7 +141,12 @@ def decode_header(value: str | bytes, default: str = "utf-8", errors: str = 'str
     """Decode the specified header value"""
     native = to_native(value, charset=default, errors=errors)
     assert native is not None  # to_native returns None only for None input
-    return "".join([to_unicode(text, charset or default, errors) for text, charset in decode_header_(native)])  # type: ignore[misc]
+    parts: list[str] = []
+    for text, charset in decode_header_(native):
+        decoded = to_unicode(text, charset or default, errors)
+        assert decoded is not None
+        parts.append(decoded)
+    return "".join(parts)
 
 
 class MessageID:
@@ -319,7 +335,7 @@ def wrapper(self: Any, *args: Any, **kwargs: Any) -> Any:
         else:
             return r
 
-    return wrapper  # type: ignore[return-value]
+    return cast(F, wrapper)
 
 
 def format_date_header(v: datetime | float | None, localtime: bool = True) -> str:

setup.cfg

@@ -16,9 +16,10 @@ disable_error_code = attr-defined, arg-type, misc, union-attr, return-value, no-
 [mypy-emails.packages.*]
 ignore_errors = true
 
-# Uses private smtplib attrs (_have_ssl) and conditional class definitions
+# Uses private smtplib attrs (_have_ssl), conditional class definitions,
+# and overrides smtplib.SMTP.sendmail with incompatible return type
 [mypy-emails.backend.smtp.client]
-disable_error_code = attr-defined, no-redef
+disable_error_code = attr-defined, no-redef, override, no-any-return, assignment
 
 # Optional dependency stubs
 [mypy-requests.*]