refactor: address pylint warnings and improve code quality

- Remove unnecessary pass statements in exception classes and methods.
- Replace f-strings with lazy % formatting in logging calls to improve performance.
- Add missing class docstrings to enums and classes for better documentation.

Author: sfo2001

aiocomfoconnect/bridge.py

@@ -56,8 +56,6 @@
 class SelfDeregistrationError(Exception):
     """Exception raised when trying to deregister self."""
 
-    pass
-
 
 class EventBus:
     """An event bus for async replies.
@@ -76,7 +74,7 @@ def add_listener(self, event_name: int, future: asyncio.Future) -> None:
             event_name (int): The event reference number.
             future (asyncio.Future): The future to be set when the event is emitted.
         """
-        _LOGGER.debug(f"Adding listener for event {event_name}")
+        _LOGGER.debug("Adding listener for event %s", event_name)
         if not self.listeners.get(event_name, None):
             self.listeners[event_name] = {future}
         else:
@@ -89,7 +87,7 @@ def emit(self, event_name: int, event: Any) -> None:
             event_name (int): The event reference number.
             event (Any): The event object or exception to set on the futures.
         """
-        _LOGGER.debug(f"Emitting for event {event_name}")
+        _LOGGER.debug("Emitting for event %s", event_name)
         futures = self.listeners.get(event_name, set())
         for future in futures:
             if isinstance(event, Exception):
@@ -165,11 +163,11 @@ async def _connect(self, uuid: str) -> asyncio.Task:
         Raises:
             AioComfoConnectTimeout: If connection times out.
         """
-        _LOGGER.debug(f"Connecting to bridge {self.host}")
+        _LOGGER.debug("Connecting to bridge %s", self.host)
         try:
             self._reader, self._writer = await asyncio.wait_for(asyncio.open_connection(self.host, self.PORT), TIMEOUT)
         except asyncio.TimeoutError as exc:
-            _LOGGER.warning(f"Timeout while connecting to bridge {self.host}")
+            _LOGGER.warning("Timeout while connecting to bridge %s", self.host)
             raise AioComfoConnectTimeout("Timeout while connecting to bridge") from exc
 
         self._reference = 1
@@ -186,7 +184,7 @@ async def _read_messages() -> None:
                     raise AioComfoConnectNotConnected("We have been disconnected") from exc
 
         self._read_task = self._loop.create_task(_read_messages())
-        _LOGGER.debug(f"Connected to bridge {self.host}")
+        _LOGGER.debug("Connected to bridge %s", self.host)
         return self._read_task
 
     async def _disconnect(self) -> None:
@@ -314,7 +312,7 @@ async def _transmit_message(self, message: Message) -> None:
         Args:
             message (Message): The message to transmit.
         """
-        _LOGGER.debug(f"TX {message}")
+        _LOGGER.debug("TX %s", message)
         self._writer.write(message.encode())
         await self._writer.drain()
         self._reference += 1
@@ -362,7 +360,7 @@ async def _read(self) -> Message:
         msg_len = int.from_bytes(msg_len_buf, byteorder="big")
         msg_buf = await self._reader.readexactly(msg_len)
         message = Message.decode(msg_buf)
-        _LOGGER.debug(f"RX {message}")
+        _LOGGER.debug("RX %s", message)
         match message.cmd.result:
             case zehnder_pb2.GatewayOperation.OK:
                 pass
@@ -411,7 +409,7 @@ async def _process_message(self) -> None:
                 case _ if message.cmd.reference:
                     self._event_bus.emit(message.cmd.reference, message.msg)
                 case _:
-                    _LOGGER.warning(f"Unhandled message type {message.cmd.type}: {message}")
+                    _LOGGER.warning("Unhandled message type %s: %s", message.cmd.type, message)
         except asyncio.IncompleteReadError as exc:
             _LOGGER.info("The connection was closed.")
             await self._disconnect()
@@ -420,7 +418,7 @@ async def _process_message(self) -> None:
             if exc.message.cmd.reference:
                 self._event_bus.emit(exc.message.cmd.reference, exc)
         except DecodeError as exc:
-            _LOGGER.error(f"Failed to decode message: {exc}")
+            _LOGGER.error("Failed to decode message: %s", exc)
 
     @log_call
     def cmd_start_session(self, take_over: bool = False) -> Awaitable[Message]:
@@ -579,7 +577,6 @@ def cmd_keepalive(self) -> Awaitable[Message]:
             reply=False,
         )
 
-
 class Message:
     """A message that is sent to the bridge.
 

aiocomfoconnect/const.py

@@ -231,6 +231,7 @@ def __str__(self) -> str:
 
 
 class VentilationTemperatureProfile(IntEnum):
+    """Enum representing ventilation temperature profiles."""
     NORMAL = 0  # 0100000000ffffffffffffffff00 = normal
     COOL = 1    # 0100000000ffffffffffffffff01 = cool
     WARM = 2    # 0100000000ffffffffffffffff02 = warm
@@ -240,6 +241,7 @@ def __str__(self) -> str:
 
 
 class VentilationSpeed(IntEnum):
+    """Enum representing ventilation speed levels."""
     AWAY = 0    # 0100000000ffffffffffffffff00 = away
     LOW = 1     # 0100000000ffffffffffffffff01 = low
     MEDIUM = 2  # 0100000000ffffffffffffffff02 = medium
@@ -250,6 +252,7 @@ def __str__(self) -> str:
 
 
 class ComfoCoolMode(IntEnum):
+    """Enum representing ComfoCool operating modes."""
     AUTO = 0x00  # protocol value for 'auto'
     OFF = 0x01   # protocol value for 'off'
 
@@ -258,6 +261,7 @@ def __str__(self) -> str:
 
 
 class BypassMode(IntEnum):
+    """Enum representing bypass operating modes."""
     AUTO = 0    # 0000000000080700000000000000 = auto
     OPEN = 1    # 0100000000100e00000b0e000001 = open
     CLOSED = 2  # 0100000000100e00000d0e000002 = closed
@@ -267,6 +271,7 @@ def __str__(self) -> str:
 
 
 class AirflowSpeed(IntEnum):
+    """Enum representing airflow speed levels."""
     AWAY = 3
     LOW = 4
     MEDIUM = 5

aiocomfoconnect/decorators.py

@@ -10,6 +10,6 @@
 def log_call(func):
     """Decorator to log method calls for command methods."""
     def wrapper(self, *args, **kwargs):
-        _LOGGER.debug(f"{func.__name__} called")
+        _LOGGER.debug("%s called", func.__name__)
         return func(self, *args, **kwargs)
     return wrapper