Convert codebase to pass mypy checks (rytilahti#1046)

* Convert codebase to pass mypy checks

This involves changes throughout the code base to make mypy happy,
which involved some minor refactoring in parts of the codebase.

This PR also adapts the CI & the pre-commit hooks to use mypy.

* Add mypy to dev dependencies

* vacuum: make carpetcleaningmode optional

* enable mypy checks for github actions

* fix linting

* run mypy only on cpython as typed_ast doesn't build on pypy

Author: rytilahti

Diff for: .github/workflows/ci.yml

@@ -44,9 +44,9 @@ jobs:
       - name: "Documentation build (sphinx)"
         run: |
           poetry run sphinx-build docs/ generated_docs
-      # - name: "Typing checks (mypy)"
-      #   run: |
-      #     poetry run pre-commit run mypy --all-files
+      - name: "Typing checks (mypy)"
+        run: |
+          poetry run pre-commit run mypy --all-files
 
   tests:
     name: "Python ${{ matrix.python-version}} on ${{ matrix.os }}"

Diff for: .pre-commit-config.yaml

@@ -47,8 +47,8 @@ repos:
     args: [-x, 'tests']
 
 
-#- repo: https://github.com/pre-commit/mirrors-mypy
-#  rev: v0.740
-#  hooks:
-#  - id: mypy
+- repo: https://github.com/pre-commit/mirrors-mypy
+  rev: v0.812
+  hooks:
+  - id: mypy
 #    args: [--no-strict-optional, --ignore-missing-imports]

Diff for: devtools/containers.py

@@ -60,7 +60,7 @@ class Property(DataClassJsonMixin):
 
     value_list: Optional[List[Dict[str, Any]]] = field(
         default_factory=list, metadata=config(field_name="value-list")
-    )
+    )  # type: ignore
     value_range: Optional[List[int]] = field(
         default=None, metadata=config(field_name="value-range")
     )

Diff for: docs/conf.py

@@ -17,6 +17,7 @@
 # add these directories to sys.path here. If the directory is relative to the
 # documentation root, use os.path.abspath to make it absolute, like shown here.
 #
+# type: ignore  # ignoring for mypy
 import os
 import sys
 

Diff for: miio/airconditioningcompanion.py

@@ -312,14 +312,14 @@ def send_ir_code(self, model: str, code: str, slot: int = 0):
         :param int slot: Unknown internal register or slot
         """
         try:
-            model = bytes.fromhex(model)
+            model_bytes = bytes.fromhex(model)
         except ValueError:
             raise AirConditioningCompanionException(
                 "Invalid model. A hexadecimal string must be provided"
             )
 
         try:
-            code = bytes.fromhex(code)
+            code_bytes = bytes.fromhex(code)
         except ValueError:
             raise AirConditioningCompanionException(
                 "Invalid code. A hexadecimal string must be provided"
@@ -328,23 +328,23 @@ def send_ir_code(self, model: str, code: str, slot: int = 0):
         if slot < 0 or slot > 134:
             raise AirConditioningCompanionException("Invalid slot: %s" % slot)
 
-        slot = bytes([121 + slot])
+        slot_bytes = bytes([121 + slot])
 
         # FE + 0487 + 00007145 + 9470 + 1FFF + 7F + FF + 06 + 0042 + 27 + 4E + 0025002D008500AC01...
-        command = (
-            code[0:1]
-            + model[2:8]
+        command_bytes = (
+            code_bytes[0:1]
+            + model_bytes[2:8]
             + b"\x94\x70\x1F\xFF"
-            + slot
+            + slot_bytes
             + b"\xFF"
-            + code[13:16]
+            + code_bytes[13:16]
             + b"\x27"
         )
 
-        checksum = sum(command) & 0xFF
-        command = command + bytes([checksum]) + code[18:]
+        checksum = sum(command_bytes) & 0xFF
+        command_bytes = command_bytes + bytes([checksum]) + code_bytes[18:]
 
-        return self.send("send_ir_code", [command.hex().upper()])
+        return self.send("send_ir_code", [command_bytes.hex().upper()])
 
     @command(
         click.argument("command", type=str),

Diff for: miio/airdehumidifier.py

@@ -174,7 +174,7 @@ def __init__(
         else:
             self.model = MODEL_DEHUMIDIFIER_V1
 
-        self.device_info = None
+        self.device_info: DeviceInfo
 
     @command(
         default_output=format_output(

Diff for: miio/airfilter_util.py

@@ -1,6 +1,6 @@
 import enum
 import re
-from typing import Optional
+from typing import Dict, Optional
 
 
 class FilterType(enum.Enum):
@@ -20,7 +20,7 @@ class FilterType(enum.Enum):
 class FilterTypeUtil:
     """Utility class for determining xiaomi air filter type."""
 
-    _filter_type_cache = {}
+    _filter_type_cache: Dict[str, Optional[FilterType]] = {}
 
     def determine_filter_type(
         self, rfid_tag: Optional[str], product_id: Optional[str]
@@ -37,7 +37,7 @@ def determine_filter_type(
         if product_id is None:
             return FilterType.Regular
 
-        ft = self._filter_type_cache.get(product_id, None)
+        ft = self._filter_type_cache.get(product_id)
         if ft is None:
             for filter_re, filter_type in FILTER_TYPE_RE:
                 if filter_re.match(product_id):

Diff for: miio/airhumidifier.py

@@ -158,6 +158,9 @@ def firmware_version(self) -> str:
 
         For example 1.2.9_5033.
         """
+        if self.device_info.firmware_version is None:
+            raise AirHumidifierException("Missing firmware information")
+
         return self.device_info.firmware_version
 
     @property
@@ -240,7 +243,8 @@ def __init__(
         else:
             self.model = MODEL_HUMIDIFIER_V1
 
-        self.device_info = None
+        # TODO: convert to use generic device info in the future
+        self.device_info: Optional[DeviceInfo] = None
 
     @command(
         default_output=format_output(
@@ -264,7 +268,6 @@ def __init__(
     )
     def status(self) -> AirHumidifierStatus:
         """Retrieve properties."""
-
         if self.device_info is None:
             self.device_info = self.info()
 

Diff for: miio/airpurifier.py

@@ -45,8 +45,6 @@ class LedBrightness(enum.Enum):
 class AirPurifierStatus(DeviceStatus):
     """Container for status reports from the air purifier."""
 
-    _filter_type_cache = {}
-
     def __init__(self, data: Dict[str, Any]) -> None:
         """Response of a Air Purifier Pro (zhimi.airpurifier.v6):
 

Diff for: miio/aqaracamera.py

@@ -38,9 +38,9 @@ class CameraOffset:
 class ArmStatus:
     """Container for arm statuses."""
 
-    is_armed = attr.ib(converter=bool)
-    arm_wait_time = attr.ib(converter=int)
-    alarm_volume = attr.ib(converter=int)
+    is_armed: bool = attr.ib(converter=bool)
+    arm_wait_time: int = attr.ib(converter=int)
+    alarm_volume: int = attr.ib(converter=int)
 
 
 class SDCardStatus(IntEnum):

Diff for: miio/chuangmi_ir.py

@@ -1,5 +1,6 @@
 import base64
 import re
+from typing import Callable, Set, Tuple
 
 import click
 from construct import (
@@ -91,10 +92,11 @@ def play_pronto(self, pronto: str, repeats: int = 1, length: int = -1):
         :param int repeats: Number of extra signal repeats.
         :param int length: Length of the command. -1 means not sending the length parameter.
         """
-        return self.play_raw(*self.pronto_to_raw(pronto, repeats), length)
+        command, frequency = self.pronto_to_raw(pronto, repeats)
+        return self.play_raw(command, frequency, length)
 
     @classmethod
-    def pronto_to_raw(cls, pronto: str, repeats: int = 1):
+    def pronto_to_raw(cls, pronto: str, repeats: int = 1) -> Tuple[str, int]:
         """Play a Pronto Hex encoded IR command. Supports only raw Pronto format,
         starting with 0000.
 
@@ -112,13 +114,13 @@ def pronto_to_raw(cls, pronto: str, repeats: int = 1):
         if len(pronto_data.intro) == 0:
             repeats += 1
 
-        times = set()
+        times: Set[int] = set()
         for pair in pronto_data.intro + pronto_data.repeat * (1 if repeats else 0):
             times.add(pair.pulse)
             times.add(pair.gap)
 
-        times = sorted(times)
-        times_map = {t: idx for idx, t in enumerate(times)}
+        times_sorted = sorted(times)
+        times_map = {t: idx for idx, t in enumerate(times_sorted)}
         edge_pairs = []
         for pair in pronto_data.intro + pronto_data.repeat * repeats:
             edge_pairs.append(
@@ -128,7 +130,7 @@ def pronto_to_raw(cls, pronto: str, repeats: int = 1):
         signal_code = base64.b64encode(
             ChuangmiIrSignal.build(
                 {
-                    "times_index": times + [0] * (16 - len(times)),
+                    "times_index": times_sorted + [0] * (16 - len(times)),
                     "edge_pairs": edge_pairs,
                 }
             )
@@ -158,18 +160,19 @@ def play(self, command: str):
         if command_type not in ["raw", "pronto"]:
             raise ChuangmiIrException("Invalid command type")
 
+        play_method: Callable
         if command_type == "raw":
             play_method = self.play_raw
 
         elif command_type == "pronto":
             play_method = self.play_pronto
 
         try:
-            command_args = [t(v) for v, t in zip(command_args, arg_types)]
+            converted_command_args = [t(v) for v, t in zip(command_args, arg_types)]
         except Exception as ex:
             raise ChuangmiIrException("Invalid command arguments") from ex
 
-        return play_method(command, *command_args)
+        return play_method(command, *converted_command_args)
 
     @command(
         click.argument("indicator_led", type=bool),

Diff for: miio/chuangmi_plug.py

@@ -6,6 +6,7 @@
 
 from .click_common import command, format_output
 from .device import Device, DeviceStatus
+from .exceptions import DeviceException
 from .utils import deprecated
 
 _LOGGER = logging.getLogger(__name__)
@@ -49,9 +50,11 @@ def power(self) -> bool:
         """Current power state."""
         if "on" in self.data:
             return self.data["on"] is True or self.data["on"] == "on"
-        if "power" in self.data:
+        elif "power" in self.data:
             return self.data["power"] == "on"
 
+        raise DeviceException("There was neither 'on' or 'power' in data")
+
     @property
     def is_on(self) -> bool:
         """True if device is on."""

Diff for: miio/click_common.py

@@ -9,7 +9,7 @@
 import re
 import sys
 from functools import partial, wraps
-from typing import Union
+from typing import Callable, Set, Type, Union
 
 import click
 
@@ -110,16 +110,16 @@ def convert(self, value, param, ctx):
 
 
 class GlobalContextObject:
-    def __init__(self, debug: int = 0, output: callable = None):
+    def __init__(self, debug: int = 0, output: Callable = None):
         self.debug = debug
         self.output = output
 
 
 class DeviceGroupMeta(type):
 
-    device_classes = set()
+    device_classes: Set[Type] = set()
 
-    def __new__(mcs, name, bases, namespace) -> type:
+    def __new__(mcs, name, bases, namespace):
         commands = {}
 
         def _get_commands_for_namespace(namespace):
@@ -264,8 +264,8 @@ def command(*decorators, name=None, default_output=None, **kwargs):
 
 
 def format_output(
-    msg_fmt: Union[str, callable] = "",
-    result_msg_fmt: Union[str, callable] = "{result}",
+    msg_fmt: Union[str, Callable] = "",
+    result_msg_fmt: Union[str, Callable] = "{result}",
 ):
     def decorator(func):
         @wraps(func)