Major Update

Author: lunDreame

custom_components/kocom_wallpad/__init__.py

@@ -7,7 +7,7 @@
 from homeassistant.config_entries import ConfigEntry
 
 from .gateway import KocomGateway
-from .const import DOMAIN, LOGGER
+from .const import DOMAIN
 
 PLATFORMS: list[Platform] = [
     Platform.BINARY_SENSOR,

custom_components/kocom_wallpad/binary_sensor.py

@@ -13,17 +13,17 @@
 from homeassistant.helpers.entity_platform import AddEntitiesCallback
 from homeassistant.helpers.dispatcher import async_dispatcher_connect
 
-from .pywallpad.const import STATE, ERROR_CODE, TIME
-from .pywallpad.packet import (
+from .pywallpad.api.kocom.const import STATE, ERROR_CODE, TIME
+from .pywallpad.api.kocom.packet import (
     KocomPacket,
     ThermostatPacket,
     FanPacket,
-    MotionPacket
+    MotionPacket,
 )
 
 from .gateway import KocomGateway
 from .entity import KocomEntity
-from .const import DOMAIN, LOGGER, DEVICE_TYPE, ROOM_ID, SUB_ID
+from .const import DOMAIN, DEVICE_TYPE, ROOM_ID, SUB_ID
 
 
 async def async_setup_entry(
@@ -41,8 +41,6 @@ def async_add_binary_sensor(packet: KocomPacket) -> None:
             async_add_entities([KocomBinarySensorEntity(gateway, packet)])
         elif isinstance(packet, MotionPacket):
             async_add_entities([KocomMotionEntity(gateway, packet)])
-        else:
-            LOGGER.warning(f"Unsupported packet type: {packet}")
 
     for entity in gateway.get_entities(Platform.BINARY_SENSOR):
         async_add_binary_sensor(entity)
@@ -70,11 +68,7 @@ def __init__(
             SUB_ID: self.device.sub_id,
             ERROR_CODE: self.device.state[ERROR_CODE],
         }
-
-    @property
-    def is_on(self) -> bool:
-        """Return true if the binary sensor is on."""
-        return self.device.state[STATE]
+        self._attr_is_on = self.device.state[STATE]
 
 
 class KocomMotionEntity(KocomEntity, BinarySensorEntity):
@@ -95,9 +89,4 @@ def __init__(
             SUB_ID: self.device.sub_id,
             TIME: self.device.state[TIME],
         }
-
-    @property
-    def is_on(self) -> bool:
-        """Return true if the binary sensor is on."""
-        return self.device.state[STATE]
-    
+        self._attr_is_on = self.device.state[STATE]

custom_components/kocom_wallpad/climate.py

@@ -19,16 +19,16 @@
 from homeassistant.helpers.entity_platform import AddEntitiesCallback
 from homeassistant.helpers.dispatcher import async_dispatcher_connect
 
-from .pywallpad.const import (
+from .pywallpad.api.kocom.const import (
     POWER,
     AWAY_MODE,
     OP_MODE,
     FAN_MODE,
     CURRENT_TEMP,
     TARGET_TEMP,
 )
-from .pywallpad.enums import OpMode, FanMode
-from .pywallpad.packet import KocomPacket, ThermostatPacket, AcPacket
+from .pywallpad.api.kocom.enums import OpMode, FanMode
+from .pywallpad.api.kocom.packet import KocomPacket, ThermostatPacket, AcPacket
 
 from .gateway import KocomGateway
 from .entity import KocomEntity
@@ -50,8 +50,6 @@ def async_add_climate(packet: KocomPacket) -> None:
             async_add_entities([KocomThermostatEntity(gateway, packet)])
         elif isinstance(packet, AcPacket):
             async_add_entities([KocomAcEntity(gateway, packet)])
-        else:
-            LOGGER.warning(f"Unsupported packet type: {packet}")
 
     for entity in gateway.get_entities(Platform.CLIMATE):
         async_add_climate(entity)
@@ -62,45 +60,35 @@ def async_add_climate(packet: KocomPacket) -> None:
 
 
 class KocomThermostatEntity(KocomEntity, ClimateEntity):
-    """Representation of a Kocom climate."""
+    """Representation of a Kocom thermostat."""
 
     _enable_turn_on_off_backwards_compatibility = False
     _attr_hvac_modes = [HVACMode.OFF, HVACMode.HEAT]
     _attr_preset_modes = [PRESET_AWAY, PRESET_NONE]
     _attr_supported_features = (
-        ClimateEntityFeature.TARGET_TEMPERATURE | 
-        ClimateEntityFeature.TURN_OFF | 
-        ClimateEntityFeature.TURN_ON |
-        ClimateEntityFeature.PRESET_MODE
+        ClimateEntityFeature.TARGET_TEMPERATURE
+        | ClimateEntityFeature.TURN_OFF
+        | ClimateEntityFeature.TURN_ON
+        | ClimateEntityFeature.PRESET_MODE
     )
     _attr_temperature_unit = UnitOfTemperature.CELSIUS
     _attr_max_temp = 40
     _attr_min_temp = 5
     _attr_target_temperature_step = 1
-    
-    def __init__(
-        self,
-        gateway: KocomGateway,
-        packet: KocomPacket,
-    ) -> None:
-        """Initialize the climate."""
+
+    def __init__(self, gateway: KocomGateway, packet: KocomPacket) -> None:
+        """Initialize the thermostat."""
         super().__init__(gateway, packet)
 
     @property
     def hvac_mode(self) -> HVACMode:
-        """Return hvac operation ie. heat, cool mode."""
-        if self.device.state[POWER]:
-            return HVACMode.HEAT
-        else:
-            return HVACMode.OFF
-        
+        """Return the current HVAC mode."""
+        return HVACMode.HEAT if self.device.state[POWER] else HVACMode.OFF
+
     @property
     def preset_mode(self) -> str:
-        """Return the current preset mode, e.g., home, away, temp."""
-        if self.device.state[AWAY_MODE]:
-            return PRESET_AWAY
-        else:
-            return PRESET_NONE
+        """Return the current preset mode."""
+        return PRESET_AWAY if self.device.state[AWAY_MODE] else PRESET_NONE
 
     @property
     def current_temperature(self) -> int:
@@ -109,42 +97,40 @@ def current_temperature(self) -> int:
 
     @property
     def target_temperature(self) -> int:
-        """Return the temperature we try to reach."""
+        """Return the target temperature."""
         return self.device.state[TARGET_TEMP]
-    
+
     async def async_set_hvac_mode(self, hvac_mode: HVACMode) -> None:
-        """Set new target hvac mode."""
-        if hvac_mode == HVACMode.OFF:
-            power = False
-        elif hvac_mode == HVACMode.HEAT:
-            power = True
-        else:
+        """Set the HVAC mode."""
+        hvac_to_power = {
+            HVACMode.OFF: False,
+            HVACMode.HEAT: True,
+        }
+        power = hvac_to_power.get(hvac_mode)
+        if power is None:
             raise ValueError(f"Unknown HVAC mode: {hvac_mode}")
-        
-        packet = self.packet.make_status(power=power)
-        await self.send(packet)
+
+        make_packet = self.packet.make_power_status(power)
+        await self.send_packet(make_packet)
 
     async def async_set_preset_mode(self, preset_mode: str) -> None:
-        """Set new target preset mode."""
-        if preset_mode == PRESET_AWAY:
-            away_mode = True
-        elif preset_mode == PRESET_NONE:
-            away_mode = False
-        else:
+        """Set the preset mode."""
+        preset_to_away = {
+            PRESET_AWAY: True,
+            PRESET_NONE: False,
+        }
+        away_mode = preset_to_away.get(preset_mode)
+        if away_mode is None:
             raise ValueError(f"Unknown preset mode: {preset_mode}")
-        
-        packet = self.packet.make_status(away_mode=away_mode)
-        await self.send(packet)
+
+        make_packet = self.packet.make_away_status(away_mode)
+        await self.send_packet(make_packet)
 
     async def async_set_temperature(self, **kwargs) -> None:
-        """Set new target temperature."""
-        target_temp = kwargs.get(ATTR_TEMPERATURE)
-        if target_temp is None:
-            LOGGER.warning("Missing temperature")
-            return
-        
-        packet = self.packet.make_status(target_temp=target_temp)
-        await self.send(packet)
+        """Set the target temperature."""
+        target_temp = int(kwargs.get(ATTR_TEMPERATURE, 0))
+        make_packet = self.packet.make_target_temp(target_temp)
+        await self.send_packet(make_packet)
 
 
 class KocomAcEntity(KocomEntity, ClimateEntity):
@@ -156,105 +142,89 @@ class KocomAcEntity(KocomEntity, ClimateEntity):
         HVACMode.COOL,
         HVACMode.FAN_ONLY,
         HVACMode.DRY,
-        HVACMode.AUTO
+        HVACMode.AUTO,
     ]
     _attr_fan_modes = [FAN_LOW, FAN_MEDIUM, FAN_HIGH]
     _attr_supported_features = (
-        ClimateEntityFeature.TARGET_TEMPERATURE | 
-        ClimateEntityFeature.TURN_OFF | 
-        ClimateEntityFeature.TURN_ON |
-        ClimateEntityFeature.FAN_MODE
+        ClimateEntityFeature.TARGET_TEMPERATURE
+        | ClimateEntityFeature.TURN_OFF
+        | ClimateEntityFeature.TURN_ON
+        | ClimateEntityFeature.FAN_MODE
     )
     _attr_temperature_unit = UnitOfTemperature.CELSIUS
     _attr_max_temp = 30
     _attr_min_temp = 18
     _attr_target_temperature_step = 1
-    
-    def __init__(
-        self,
-        gateway: KocomGateway,
-        packet: KocomPacket,
-    ) -> None:
+
+    def __init__(self, gateway: KocomGateway, packet: KocomPacket) -> None:
         """Initialize the climate."""
         super().__init__(gateway, packet)
-        
+
     @property
     def hvac_mode(self) -> HVACMode:
-        """Return hvac operation ie. heat, cool mode."""
-        if self.device.state[POWER] and (op_mode := self.device.state[OP_MODE]):
-            if op_mode == OpMode.COOL:
-                return HVACMode.COOL
-            elif op_mode == OpMode.FAN_ONLY:
-                return HVACMode.FAN_ONLY
-            elif op_mode == OpMode.DRY:
-                return HVACMode.DRY
-            elif op_mode == OpMode.AUTO:
-                return HVACMode.AUTO
-        else:
-            return HVACMode.OFF
-    
+        """Return current HVAC mode."""
+        if self.device.state[POWER]:
+            op_mode = self.device.state[OP_MODE]
+            return {
+                OpMode.COOL: HVACMode.COOL,
+                OpMode.FAN_ONLY: HVACMode.FAN_ONLY,
+                OpMode.DRY: HVACMode.DRY,
+                OpMode.AUTO: HVACMode.AUTO,
+            }.get(op_mode, HVACMode.OFF)
+        return HVACMode.OFF
+
     @property
     def fan_mode(self) -> str:
-        """Return the fan setting."""
-        fan_mode = self.device.state[FAN_MODE]
-        if fan_mode == FanMode.LOW:
-            return FAN_LOW
-        elif fan_mode == FanMode.MEDIUM:
-            return FAN_MEDIUM
-        elif fan_mode == FanMode.HIGH:
-            return FAN_HIGH
-        
+        """Return current fan mode."""
+        return {
+            FanMode.LOW: FAN_LOW,
+            FanMode.MEDIUM: FAN_MEDIUM,
+            FanMode.HIGH: FAN_HIGH,
+        }.get(self.device.state[FAN_MODE])
+
     @property
     def current_temperature(self) -> int:
         """Return the current temperature."""
         return self.device.state[CURRENT_TEMP]
 
     @property
     def target_temperature(self) -> int:
-        """Return the temperature we try to reach."""
+        """Return the target temperature."""
         return self.device.state[TARGET_TEMP]
-    
+
     async def async_set_hvac_mode(self, hvac_mode: HVACMode) -> None:
-        """Set new target hvac mode."""
+        """Set a new target HVAC mode."""
         if hvac_mode == HVACMode.OFF:
-            op_mode = OpMode.OFF
-        elif hvac_mode == HVACMode.COOL:
-            op_mode = OpMode.COOL
-        elif hvac_mode == HVACMode.FAN_ONLY:
-            op_mode = OpMode.FAN_ONLY
-        elif hvac_mode == HVACMode.DRY:
-            op_mode = OpMode.DRY
-        elif hvac_mode == HVACMode.AUTO:
-           op_mode = OpMode.AUTO
+            make_packet = self.packet.make_power_status(False)
         else:
-            raise ValueError(f"Unknown HVAC mode: {hvac_mode}")
-               
-        packet = self.packet.make_status(op_mode=op_mode)
-        await self.send(packet)
+            hvac_to_op_mode = {
+                HVACMode.COOL: OpMode.COOL,
+                HVACMode.FAN_ONLY: OpMode.FAN_ONLY,
+                HVACMode.DRY: OpMode.DRY,
+                HVACMode.AUTO: OpMode.AUTO,
+            }
+            op_mode = hvac_to_op_mode.get(hvac_mode)
+            if op_mode is None:
+                raise ValueError(f"Unknown HVAC mode: {hvac_mode}")
+            make_packet = self.packet.make_op_mode(op_mode)
+
+        await self.send_packet(make_packet)
 
     async def async_set_fan_mode(self, fan_mode: str) -> None:
-        """Set new target fan mode."""
-        if fan_mode == FAN_LOW:
-            fan_speed = FanMode.LOW
-        elif fan_mode == FAN_MEDIUM:
-            fan_speed = FanMode.MEDIUM
-        elif fan_mode == FAN_HIGH:
-            fan_speed = FanMode.HIGH
-        else:
+        """Set a new target fan mode."""
+        fan_speed = {
+            FAN_LOW: FanMode.LOW,
+            FAN_MEDIUM: FanMode.MEDIUM,
+            FAN_HIGH: FanMode.HIGH,
+        }.get(fan_mode)
+        if fan_speed is None:
             raise ValueError(f"Unknown fan mode: {fan_mode}")
-        
-        packet = self.packet.make_status(fan_mode=fan_speed)
-        await self.send(packet)
-        
-    async def async_set_preset_mode(self, preset_mode: str) -> None:
-        """Set new target preset mode."""
+
+        make_packet = self.packet.make_fan_mode(fan_speed)
+        await self.send_packet(make_packet)
 
     async def async_set_temperature(self, **kwargs) -> None:
-        """Set new target temperature."""
-        target_temp = kwargs.get(ATTR_TEMPERATURE)
-        if target_temp is None:
-            LOGGER.warning("Missing temperature")
-            return
-        
-        packet = self.packet.make_status(target_temp=target_temp)
-        await self.send(packet)
+        """Set a new target temperature."""
+        target_temp = int(kwargs.get(ATTR_TEMPERATURE, 0))
+        make_packet = self.packet.make_target_temp(target_temp)
+        await self.send_packet(make_packet)