chore: inheritance fixes and simplifications (#282)

Author: allenporter

roborock/api.py

@@ -7,6 +7,7 @@
 import logging
 import secrets
 import time
+from abc import ABC, abstractmethod
 from typing import Any
 
 from .containers import (
@@ -21,17 +22,21 @@
     RoborockMessage,
 )
 from .roborock_typing import RoborockCommand
-from .util import RoborockLoggerAdapter, get_next_int, get_running_loop_or_create_one
+from .util import get_next_int, get_running_loop_or_create_one
 
 _LOGGER = logging.getLogger(__name__)
 KEEPALIVE = 60
 
 
-class RoborockClient:
-    def __init__(self, endpoint: str, device_info: DeviceData, queue_timeout: int = 4) -> None:
+class RoborockClient(ABC):
+    """Roborock client base class."""
+
+    _logger: logging.LoggerAdapter
+
+    def __init__(self, device_info: DeviceData, queue_timeout: int = 4) -> None:
+        """Initialize RoborockClient."""
         self.event_loop = get_running_loop_or_create_one()
         self.device_info = device_info
-        self._endpoint = endpoint
         self._nonce = secrets.token_bytes(16)
         self._waiting_queue: dict[int, RoborockFuture] = {}
         self._last_device_msg_in = time.monotonic()
@@ -40,7 +45,6 @@ def __init__(self, endpoint: str, device_info: DeviceData, queue_timeout: int =
         self._diagnostic_data: dict[str, dict[str, Any]] = {
             "misc_info": {"Nonce": base64.b64encode(self._nonce).decode("utf-8")}
         }
-        self._logger = RoborockLoggerAdapter(device_info.device.name, _LOGGER)
         self.is_available: bool = True
         self.queue_timeout = queue_timeout
 
@@ -57,17 +61,21 @@ async def async_release(self) -> None:
     def diagnostic_data(self) -> dict:
         return self._diagnostic_data
 
+    @abstractmethod
     async def async_connect(self):
-        raise NotImplementedError
+        """Connect to the Roborock device."""
 
+    @abstractmethod
     def sync_disconnect(self) -> Any:
-        raise NotImplementedError
+        """Disconnect from the Roborock device."""
 
+    @abstractmethod
     async def async_disconnect(self) -> Any:
-        raise NotImplementedError
+        """Disconnect from the Roborock device."""
 
+    @abstractmethod
     def on_message_received(self, messages: list[RoborockMessage]) -> None:
-        raise NotImplementedError
+        """Handle received incoming messages from the device."""
 
     def on_connection_lost(self, exc: Exception | None) -> None:
         self._last_disconnection = time.monotonic()
@@ -102,7 +110,7 @@ def _async_response(self, request_id: int, protocol_id: int = 0) -> Any:
         queue = RoborockFuture(protocol_id)
         if request_id in self._waiting_queue:
             new_id = get_next_int(10000, 32767)
-            _LOGGER.warning(
+            self._logger.warning(
                 "Attempting to create a future with an existing id %s (%s)... New id is %s. "
                 "Code may not function properly.",
                 request_id,
@@ -113,12 +121,14 @@ def _async_response(self, request_id: int, protocol_id: int = 0) -> Any:
         self._waiting_queue[request_id] = queue
         return asyncio.ensure_future(self._wait_response(request_id, queue))
 
+    @abstractmethod
     async def send_message(self, roborock_message: RoborockMessage):
-        raise NotImplementedError
+        """Send a message to the Roborock device."""
 
+    @abstractmethod
     async def _send_command(
         self,
         method: RoborockCommand | str,
         params: list | dict | int | None = None,
     ):
-        raise NotImplementedError
+        """Send a command to the Roborock device."""

roborock/cloud_api.py

@@ -1,9 +1,9 @@
 from __future__ import annotations
 
-import base64
 import logging
 import threading
 import uuid
+from abc import ABC
 from asyncio import Lock
 from typing import Any
 from urllib.parse import urlparse
@@ -13,29 +13,24 @@
 from .api import KEEPALIVE, RoborockClient
 from .containers import DeviceData, UserData
 from .exceptions import RoborockException, VacuumError
-from .protocol import MessageParser, Utils, md5hex
+from .protocol import MessageParser, md5hex
 from .roborock_future import RoborockFuture
-from .roborock_message import RoborockMessage
-from .roborock_typing import RoborockCommand
-from .util import RoborockLoggerAdapter
 
 _LOGGER = logging.getLogger(__name__)
 CONNECT_REQUEST_ID = 0
 DISCONNECT_REQUEST_ID = 1
 
 
-class RoborockMqttClient(RoborockClient, mqtt.Client):
+class RoborockMqttClient(RoborockClient, mqtt.Client, ABC):
     _thread: threading.Thread
     _client_id: str
 
     def __init__(self, user_data: UserData, device_info: DeviceData, queue_timeout: int = 10) -> None:
         rriot = user_data.rriot
         if rriot is None:
             raise RoborockException("Got no rriot data from user_data")
-        endpoint = base64.b64encode(Utils.md5(rriot.k.encode())[8:14]).decode()
-        RoborockClient.__init__(self, endpoint, device_info, queue_timeout)
+        RoborockClient.__init__(self, device_info, queue_timeout)
         mqtt.Client.__init__(self, protocol=mqtt.MQTTv5)
-        self._logger = RoborockLoggerAdapter(device_info.device.name, _LOGGER)
         self._mqtt_user = rriot.u
         self._hashed_user = md5hex(self._mqtt_user + ":" + rriot.k)[2:10]
         url = urlparse(rriot.r.m)
@@ -49,7 +44,6 @@ def __init__(self, user_data: UserData, device_info: DeviceData, queue_timeout:
         self._mqtt_password = rriot.s
         self._hashed_password = md5hex(self._mqtt_password + ":" + rriot.k)[16:]
         super().username_pw_set(self._hashed_user, self._hashed_password)
-        self._endpoint = base64.b64encode(Utils.md5(rriot.k.encode())[8:14]).decode()
         self._waiting_queue: dict[int, RoborockFuture] = {}
         self._mutex = Lock()
         self.update_client_id()
@@ -164,13 +158,3 @@ def _send_msg_raw(self, msg: bytes) -> None:
         info = self.publish(f"rr/m/i/{self._mqtt_user}/{self._hashed_user}/{self.device_info.device.duid}", msg)
         if info.rc != mqtt.MQTT_ERR_SUCCESS:
             raise RoborockException(f"Failed to publish ({mqtt.error_string(info.rc)})")
-
-    async def send_message(self, roborock_message: RoborockMessage):
-        raise NotImplementedError
-
-    async def _send_command(
-        self,
-        method: RoborockCommand | str,
-        params: list | dict | int | None = None,
-    ):
-        raise NotImplementedError

roborock/local_api.py

@@ -2,6 +2,7 @@
 
 import asyncio
 import logging
+from abc import ABC
 from asyncio import Lock, TimerHandle, Transport
 
 import async_timeout
@@ -11,14 +12,15 @@
 from .exceptions import RoborockConnectionException, RoborockException
 from .protocol import MessageParser
 from .roborock_message import RoborockMessage, RoborockMessageProtocol
-from .roborock_typing import RoborockCommand
-from .util import RoborockLoggerAdapter
 
 _LOGGER = logging.getLogger(__name__)
 
 
-class RoborockLocalClient(RoborockClient, asyncio.Protocol):
+class RoborockLocalClient(RoborockClient, asyncio.Protocol, ABC):
+    """Roborock local client base class."""
+
     def __init__(self, device_data: DeviceData, queue_timeout: int = 4):
+        """Initialize the Roborock local client."""
         if device_data.host is None:
             raise RoborockException("Host is required")
         self.host = device_data.host
@@ -28,8 +30,7 @@ def __init__(self, device_data: DeviceData, queue_timeout: int = 4):
         self.transport: Transport | None = None
         self._mutex = Lock()
         self.keep_alive_task: TimerHandle | None = None
-        self._logger = RoborockLoggerAdapter(device_data.device.name, _LOGGER)
-        RoborockClient.__init__(self, "abc", device_data, queue_timeout)
+        RoborockClient.__init__(self, device_data, queue_timeout)
 
     def data_received(self, message):
         if self.remaining:
@@ -107,13 +108,6 @@ async def ping(self) -> None:
             )
         )
 
-    async def _send_command(
-        self,
-        method: RoborockCommand | str,
-        params: list | dict | int | None = None,
-    ):
-        raise NotImplementedError
-
     def _send_msg_raw(self, data: bytes):
         try:
             if not self.transport:

roborock/version_1_apis/roborock_client_v1.py

@@ -4,6 +4,7 @@
 import math
 import struct
 import time
+from abc import ABC
 from collections.abc import Callable, Coroutine
 from typing import Any, TypeVar, final
 
@@ -142,19 +143,22 @@ class ListenerModel:
     cache: dict[CacheableAttribute, AttributeCache]
 
 
-class RoborockClientV1(RoborockClient):
+class RoborockClientV1(RoborockClient, ABC):
+    """Roborock client base class for version 1 devices."""
+
     _listeners: dict[str, ListenerModel] = {}
 
-    def __init__(self, device_info: DeviceData, logger, endpoint: str):
-        super().__init__(endpoint, device_info)
+    def __init__(self, device_info: DeviceData, endpoint: str):
+        """Initializes the Roborock client."""
+        super().__init__(device_info)
         self._status_type: type[Status] = ModelStatus.get(device_info.model, S7MaxVStatus)
-        self._logger = logger
         self.cache: dict[CacheableAttribute, AttributeCache] = {
             cacheable_attribute: AttributeCache(attr, self) for cacheable_attribute, attr in get_cache_map().items()
         }
         if device_info.device.duid not in self._listeners:
             self._listeners[device_info.device.duid] = ListenerModel({}, self.cache)
         self.listener_model = self._listeners[device_info.device.duid]
+        self._endpoint = endpoint
 
     def release(self):
         super().release()

roborock/version_1_apis/roborock_local_client_v1.py

@@ -1,16 +1,25 @@
+import logging
+
 from roborock.local_api import RoborockLocalClient
 
 from .. import CommandVacuumError, DeviceData, RoborockCommand, RoborockException
 from ..exceptions import VacuumError
 from ..protocol import MessageParser
 from ..roborock_message import MessageRetry, RoborockMessage, RoborockMessageProtocol
+from ..util import RoborockLoggerAdapter
 from .roborock_client_v1 import COMMANDS_SECURED, RoborockClientV1
 
+_LOGGER = logging.getLogger(__name__)
+
 
 class RoborockLocalClientV1(RoborockLocalClient, RoborockClientV1):
+    """Roborock local client for v1 devices."""
+
     def __init__(self, device_data: DeviceData, queue_timeout: int = 4):
+        """Initialize the Roborock local client."""
         RoborockLocalClient.__init__(self, device_data, queue_timeout)
-        RoborockClientV1.__init__(self, device_data, self._logger, "abc")
+        RoborockClientV1.__init__(self, device_data, "abc")
+        self._logger = RoborockLoggerAdapter(device_data.device.name, _LOGGER)
 
     def build_roborock_message(
         self, method: RoborockCommand | str, params: list | dict | int | None = None

roborock/version_1_apis/roborock_mqtt_client_v1.py

@@ -1,6 +1,6 @@
 import base64
+import logging
 
-import paho.mqtt.client as mqtt
 from vacuum_map_parser_base.config.color import ColorsPalette
 from vacuum_map_parser_base.config.image_config import ImageConfig
 from vacuum_map_parser_base.config.size import Sizes
@@ -16,23 +16,25 @@
     RoborockMessageProtocol,
 )
 from ..roborock_typing import RoborockCommand
+from ..util import RoborockLoggerAdapter
 from .roborock_client_v1 import COMMANDS_SECURED, CUSTOM_COMMANDS, RoborockClientV1
 
+_LOGGER = logging.getLogger(__name__)
+
 
 class RoborockMqttClientV1(RoborockMqttClient, RoborockClientV1):
+    """Roborock mqtt client for v1 devices."""
+
     def __init__(self, user_data: UserData, device_info: DeviceData, queue_timeout: int = 10) -> None:
+        """Initialize the Roborock mqtt client."""
         rriot = user_data.rriot
         if rriot is None:
             raise RoborockException("Got no rriot data from user_data")
         endpoint = base64.b64encode(Utils.md5(rriot.k.encode())[8:14]).decode()
 
         RoborockMqttClient.__init__(self, user_data, device_info, queue_timeout)
-        RoborockClientV1.__init__(self, device_info, self._logger, endpoint)
-
-    def _send_msg_raw(self, msg: bytes) -> None:
-        info = self.publish(f"rr/m/i/{self._mqtt_user}/{self._hashed_user}/{self.device_info.device.duid}", msg)
-        if info.rc != mqtt.MQTT_ERR_SUCCESS:
-            raise RoborockException(f"Failed to publish ({mqtt.error_string(info.rc)})")
+        RoborockClientV1.__init__(self, device_info, endpoint)
+        self._logger = RoborockLoggerAdapter(device_info.device.name, _LOGGER)
 
     async def send_message(self, roborock_message: RoborockMessage):
         await self.validate_connection()

roborock/version_a01_apis/roborock_client_a01.py

@@ -1,6 +1,8 @@
 import dataclasses
 import json
+import logging
 import typing
+from abc import ABC, abstractmethod
 from collections.abc import Callable
 from datetime import time
 
@@ -38,6 +40,8 @@
     RoborockZeoProtocol,
 )
 
+_LOGGER = logging.getLogger(__name__)
+
 
 @dataclasses.dataclass
 class A01ProtocolCacheEntry:
@@ -101,9 +105,12 @@ class A01ProtocolCacheEntry:
 }
 
 
-class RoborockClientA01(RoborockClient):
-    def __init__(self, endpoint: str, device_info: DeviceData, category: RoborockCategory, queue_timeout: int = 4):
-        super().__init__(endpoint, device_info, queue_timeout)
+class RoborockClientA01(RoborockClient, ABC):
+    """Roborock client base class for A01 devices."""
+
+    def __init__(self, device_info: DeviceData, category: RoborockCategory, queue_timeout: int = 4):
+        """Initialize the Roborock client."""
+        super().__init__(device_info, queue_timeout)
         self.category = category
 
     def on_message_received(self, messages: list[RoborockMessage]) -> None:
@@ -137,8 +144,8 @@ def on_message_received(self, messages: list[RoborockMessage]) -> None:
                         if queue and queue.protocol == protocol:
                             queue.set_result(converted_response)
 
+    @abstractmethod
     async def update_values(
         self, dyad_data_protocols: list[RoborockDyadDataProtocol | RoborockZeoProtocol]
     ) -> dict[RoborockDyadDataProtocol | RoborockZeoProtocol, typing.Any]:
         """This should handle updating for each given protocol."""
-        raise NotImplementedError