Split entity between entity and executor logic [refactor] (#506)

custom_components/tahoma/alarm_control_panel.py

@@ -25,7 +25,7 @@
 from homeassistant.helpers.entity_platform import AddEntitiesCallback
 
 from .const import DOMAIN
-from .tahoma_entity import TahomaEntity
+from .entity import OverkizEntity
 
 COMMAND_ALARM_OFF = "alarmOff"
 COMMAND_ALARM_ON = "alarmOn"
@@ -95,14 +95,16 @@ async def async_setup_entry(
     async_add_entities(entities)
 
 
-class TahomaAlarmControlPanel(TahomaEntity, AlarmControlPanelEntity):
+class TahomaAlarmControlPanel(OverkizEntity, AlarmControlPanelEntity):
     """Representation of a TaHoma Alarm Control Panel."""
 
     @property
     def state(self):
         """Return the state of the device."""
-        if self.has_state(CORE_INTRUSION_STATE, INTERNAL_INTRUSION_DETECTED_STATE):
-            state = self.select_state(
+        if self.executor.has_state(
+            CORE_INTRUSION_STATE, INTERNAL_INTRUSION_DETECTED_STATE
+        ):
+            state = self.executor.select_state(
                 CORE_INTRUSION_STATE, INTERNAL_INTRUSION_DETECTED_STATE
             )
             if state == STATE_DETECTED:
@@ -111,24 +113,26 @@ def state(self):
                 return STATE_ALARM_PENDING
 
         if (
-            self.has_state(INTERNAL_CURRENT_ALARM_MODE_STATE)
-            and self.has_state(INTERNAL_TARGET_ALARM_MODE_STATE)
-            and self.select_state(INTERNAL_CURRENT_ALARM_MODE_STATE)
-            != self.select_state(INTERNAL_TARGET_ALARM_MODE_STATE)
+            self.executor.has_state(INTERNAL_CURRENT_ALARM_MODE_STATE)
+            and self.executor.has_state(INTERNAL_TARGET_ALARM_MODE_STATE)
+            and self.executor.select_state(INTERNAL_CURRENT_ALARM_MODE_STATE)
+            != self.executor.select_state(INTERNAL_TARGET_ALARM_MODE_STATE)
         ):
             return STATE_ALARM_PENDING
 
-        if self.has_state(MYFOX_ALARM_STATUS_STATE):
-            return MAP_MYFOX_STATUS_STATE[self.select_state(MYFOX_ALARM_STATUS_STATE)]
+        if self.executor.has_state(MYFOX_ALARM_STATUS_STATE):
+            return MAP_MYFOX_STATUS_STATE[
+                self.executor.select_state(MYFOX_ALARM_STATUS_STATE)
+            ]
 
-        if self.has_state(INTERNAL_CURRENT_ALARM_MODE_STATE):
+        if self.executor.has_state(INTERNAL_CURRENT_ALARM_MODE_STATE):
             return MAP_INTERNAL_STATUS_STATE[
-                self.select_state(INTERNAL_CURRENT_ALARM_MODE_STATE)
+                self.executor.select_state(INTERNAL_CURRENT_ALARM_MODE_STATE)
             ]
 
-        if self.has_state(VERISURE_ALARM_PANEL_MAIN_ARM_TYPE_STATE):
+        if self.executor.has_state(VERISURE_ALARM_PANEL_MAIN_ARM_TYPE_STATE):
             return MAP_VERISURE_STATUS_STATE[
-                self.select_state(VERISURE_ALARM_PANEL_MAIN_ARM_TYPE_STATE)
+                self.executor.select_state(VERISURE_ALARM_PANEL_MAIN_ARM_TYPE_STATE)
             ]
 
         return None
@@ -138,59 +142,59 @@ def supported_features(self) -> int:
         """Return the list of supported features."""
         supported_features = 0
 
-        if self.has_command(COMMAND_ARM, COMMAND_ALARM_ON):
+        if self.executor.has_command(COMMAND_ARM, COMMAND_ALARM_ON):
             supported_features |= SUPPORT_ALARM_ARM_AWAY
 
-        if self.has_command(COMMAND_ALARM_PARTIAL_1, COMMAND_ARM_PARTIAL_DAY):
+        if self.executor.has_command(COMMAND_ALARM_PARTIAL_1, COMMAND_ARM_PARTIAL_DAY):
             supported_features |= SUPPORT_ALARM_ARM_HOME
 
-        if self.has_command(
+        if self.executor.has_command(
             COMMAND_PARTIAL, COMMAND_ALARM_PARTIAL_2, COMMAND_ARM_PARTIAL_NIGHT
         ):
             supported_features |= SUPPORT_ALARM_ARM_NIGHT
 
-        if self.has_command(COMMAND_SET_ALARM_STATUS):
+        if self.executor.has_command(COMMAND_SET_ALARM_STATUS):
             supported_features |= SUPPORT_ALARM_TRIGGER
             supported_features |= SUPPORT_ALARM_ARM_CUSTOM_BYPASS
 
         return supported_features
 
     async def async_alarm_disarm(self, code=None):
         """Send disarm command."""
-        await self.async_execute_command(
-            self.select_command(COMMAND_DISARM, COMMAND_ALARM_OFF)
+        await self.executor.async_execute_command(
+            self.executor.select_command(COMMAND_DISARM, COMMAND_ALARM_OFF)
         )
 
     async def async_alarm_arm_home(self, code=None):
         """Send arm home command."""
-        await self.async_execute_command(
+        await self.executor.async_execute_command(
             COMMAND_ALARM_PARTIAL_1, COMMAND_ARM_PARTIAL_DAY
         )
 
     async def async_alarm_arm_night(self, code=None):
         """Send arm night command."""
-        await self.async_execute_command(
-            self.select_command(
+        await self.executor.async_execute_command(
+            self.executor.select_command(
                 COMMAND_PARTIAL, COMMAND_ALARM_PARTIAL_2, COMMAND_ARM_PARTIAL_NIGHT
             )
         )
 
     async def async_alarm_arm_away(self, code=None):
         """Send arm away command."""
-        await self.async_execute_command(
-            self.select_command(COMMAND_ARM, COMMAND_ALARM_ON)
+        await self.executor.async_execute_command(
+            self.executor.select_command(COMMAND_ARM, COMMAND_ALARM_ON)
         )
 
     async def async_alarm_trigger(self, code=None) -> None:
         """Send alarm trigger command."""
-        await self.async_execute_command(
-            self.select_command(COMMAND_SET_ALARM_STATUS, STATE_DETECTED)
+        await self.executor.async_execute_command(
+            self.executor.select_command(COMMAND_SET_ALARM_STATUS, STATE_DETECTED)
         )
 
     async def async_alarm_arm_custom_bypass(self, code=None) -> None:
         """Send arm custom bypass command."""
-        await self.async_execute_command(
-            self.select_command(COMMAND_SET_ALARM_STATUS, STATE_UNDETECTED)
+        await self.executor.async_execute_command(
+            self.executor.select_command(COMMAND_SET_ALARM_STATUS, STATE_UNDETECTED)
         )
 
     @property

custom_components/tahoma/binary_sensor.py

@@ -16,7 +16,7 @@
 
 from .const import DOMAIN
 from .coordinator import TahomaDataUpdateCoordinator
-from .tahoma_entity import TahomaEntity
+from .entity import OverkizEntity
 
 STATE_OPEN = "open"
 STATE_PERSON_INSIDE = "personInside"
@@ -121,7 +121,7 @@ async def async_setup_entry(
     async_add_entities(entities)
 
 
-class TahomaBinarySensor(TahomaEntity, BinarySensorEntity):
+class TahomaBinarySensor(OverkizEntity, BinarySensorEntity):
     """Representation of a TaHoma Binary Sensor."""
 
     def __init__(

custom_components/tahoma/climate_devices/atlantic_electrical_heater.py

@@ -14,7 +14,7 @@
 )
 from homeassistant.const import TEMP_CELSIUS
 
-from ..tahoma_entity import TahomaEntity
+from ..entity import OverkizEntity
 
 COMMAND_SET_HEATING_LEVEL = "setHeatingLevel"
 
@@ -44,7 +44,7 @@
 HVAC_MODES_TO_TAHOMA = {v: k for k, v in TAHOMA_TO_HVAC_MODES.items()}
 
 
-class AtlanticElectricalHeater(TahomaEntity, ClimateEntity):
+class AtlanticElectricalHeater(OverkizEntity, ClimateEntity):
     """Representation of Atlantic Electrical Heater."""
 
     @property
@@ -60,7 +60,7 @@ def supported_features(self) -> int:
     @property
     def hvac_mode(self) -> str:
         """Return hvac operation ie. heat, cool mode."""
-        return TAHOMA_TO_HVAC_MODES[self.select_state(CORE_ON_OFF_STATE)]
+        return TAHOMA_TO_HVAC_MODES[self.executor.select_state(CORE_ON_OFF_STATE)]
 
     @property
     def hvac_modes(self) -> List[str]:
@@ -69,14 +69,16 @@ def hvac_modes(self) -> List[str]:
 
     async def async_set_hvac_mode(self, hvac_mode: str) -> None:
         """Set new target hvac mode."""
-        await self.async_execute_command(
+        await self.executor.async_execute_command(
             COMMAND_SET_HEATING_LEVEL, HVAC_MODES_TO_TAHOMA[hvac_mode]
         )
 
     @property
     def preset_mode(self) -> Optional[str]:
         """Return the current preset mode, e.g., home, away, temp."""
-        return TAHOMA_TO_PRESET_MODES[self.select_state(IO_TARGET_HEATING_LEVEL_STATE)]
+        return TAHOMA_TO_PRESET_MODES[
+            self.executor.select_state(IO_TARGET_HEATING_LEVEL_STATE)
+        ]
 
     @property
     def preset_modes(self) -> Optional[List[str]]:
@@ -85,6 +87,6 @@ def preset_modes(self) -> Optional[List[str]]:
 
     async def async_set_preset_mode(self, preset_mode: str) -> None:
         """Set new preset mode."""
-        await self.async_execute_command(
+        await self.executor.async_execute_command(
             COMMAND_SET_HEATING_LEVEL, PRESET_MODES_TO_TAHOMA[preset_mode]
         )

custom_components/tahoma/climate_devices/atlantic_electrical_heater_with_adjustable_temperature_setpoint.py

@@ -26,7 +26,7 @@
 from homeassistant.helpers.event import async_track_state_change
 
 from ..coordinator import TahomaDataUpdateCoordinator
-from ..tahoma_entity import TahomaEntity
+from ..entity import OverkizEntity
 
 _LOGGER = logging.getLogger(__name__)
 
@@ -80,7 +80,7 @@
 
 
 class AtlanticElectricalHeaterWithAdjustableTemperatureSetpoint(
-    TahomaEntity, ClimateEntity
+    OverkizEntity, ClimateEntity
 ):
     """Representation of Atlantic Electrical Heater (With Adjustable Temperature Setpoint)."""
 
@@ -164,10 +164,10 @@ def supported_features(self) -> int:
         """Return the list of supported features."""
         supported_features = 0
 
-        if self.has_command(COMMAND_SET_HEATING_LEVEL):
+        if self.executor.has_command(COMMAND_SET_HEATING_LEVEL):
             supported_features |= SUPPORT_PRESET_MODE
 
-        if self.has_command(COMMAND_SET_TARGET_TEMPERATURE):
+        if self.executor.has_command(COMMAND_SET_TARGET_TEMPERATURE):
             supported_features |= SUPPORT_TARGET_TEMPERATURE
 
         return supported_features
@@ -181,23 +181,25 @@ def hvac_modes(self) -> List[str]:
     def hvac_mode(self) -> str:
         """Return hvac operation ie. heat, cool mode."""
         if CORE_OPERATING_MODE_STATE in self.device.states:
-            return TAHOMA_TO_HVAC_MODE[self.select_state(CORE_OPERATING_MODE_STATE)]
+            return TAHOMA_TO_HVAC_MODE[
+                self.executor.select_state(CORE_OPERATING_MODE_STATE)
+            ]
         if CORE_ON_OFF_STATE in self.device.states:
-            return TAHOMA_TO_HVAC_MODE[self.select_state(CORE_ON_OFF_STATE)]
+            return TAHOMA_TO_HVAC_MODE[self.executor.select_state(CORE_ON_OFF_STATE)]
 
     async def async_set_hvac_mode(self, hvac_mode: str) -> None:
         """Set new target hvac mode."""
         if CORE_OPERATING_MODE_STATE in self.device.states:
-            await self.async_execute_command(
+            await self.executor.async_execute_command(
                 COMMAND_SET_OPERATING_MODE, HVAC_MODE_TO_TAHOMA[hvac_mode]
             )
         else:
             if hvac_mode == HVAC_MODE_OFF:
-                await self.async_execute_command(
+                await self.executor.async_execute_command(
                     COMMAND_OFF,
                 )
             else:
-                await self.async_execute_command(
+                await self.executor.async_execute_command(
                     COMMAND_SET_HEATING_LEVEL, PRESET_STATE_COMFORT
                 )
 
@@ -209,24 +211,26 @@ def preset_modes(self) -> Optional[List[str]]:
     @property
     def preset_mode(self) -> Optional[str]:
         """Return the current preset mode, e.g., home, away, temp."""
-        return TAHOMA_TO_PRESET_MODE[self.select_state(IO_TARGET_HEATING_LEVEL_STATE)]
+        return TAHOMA_TO_PRESET_MODE[
+            self.executor.select_state(IO_TARGET_HEATING_LEVEL_STATE)
+        ]
 
     async def async_set_preset_mode(self, preset_mode: str) -> None:
         """Set new preset mode."""
         if preset_mode == PRESET_AUTO or preset_mode == PRESET_PROG:
-            await self.async_execute_command(
+            await self.executor.async_execute_command(
                 COMMAND_SET_OPERATING_MODE, PRESET_MODE_TO_TAHOMA[preset_mode]
             )
         else:
-            await self.async_execute_command(
+            await self.executor.async_execute_command(
                 COMMAND_SET_HEATING_LEVEL, PRESET_MODE_TO_TAHOMA[preset_mode]
             )
 
     @property
     def target_temperature(self) -> None:
         """Return the temperature."""
         if CORE_TARGET_TEMPERATURE_STATE in self.device.states:
-            return self.select_state(CORE_TARGET_TEMPERATURE_STATE)
+            return self.executor.select_state(CORE_TARGET_TEMPERATURE_STATE)
 
     @property
     def current_temperature(self):
@@ -236,4 +240,6 @@ def current_temperature(self):
     async def async_set_temperature(self, **kwargs) -> None:
         """Set new temperature."""
         temperature = kwargs.get(ATTR_TEMPERATURE)
-        await self.async_execute_command(COMMAND_SET_TARGET_TEMPERATURE, temperature)
+        await self.executor.async_execute_command(
+            COMMAND_SET_TARGET_TEMPERATURE, temperature
+        )

custom_components/tahoma/climate_devices/atlantic_electrical_towel_dryer.py

@@ -15,7 +15,7 @@
 )
 from homeassistant.const import ATTR_TEMPERATURE, TEMP_CELSIUS
 
-from ..tahoma_entity import TahomaEntity
+from ..entity import OverkizEntity
 
 _LOGGER = logging.getLogger(__name__)
 
@@ -63,7 +63,7 @@
 HVAC_MODE_TO_TAHOMA = {v: k for k, v in TAHOMA_TO_HVAC_MODE.items()}
 
 
-class AtlanticElectricalTowelDryer(TahomaEntity, ClimateEntity):
+class AtlanticElectricalTowelDryer(OverkizEntity, ClimateEntity):
     """Representation of Atlantic Electrical Towel Dryer."""
 
     @property
@@ -85,14 +85,16 @@ def hvac_modes(self) -> List[str]:
     def hvac_mode(self) -> str:
         """Return hvac operation ie. heat, cool mode."""
         if CORE_OPERATING_MODE_STATE in self.device.states:
-            return TAHOMA_TO_HVAC_MODE[self.select_state(CORE_OPERATING_MODE_STATE)]
+            return TAHOMA_TO_HVAC_MODE[
+                self.executor.select_state(CORE_OPERATING_MODE_STATE)
+            ]
 
         if CORE_ON_OFF_STATE in self.device.states:
-            return TAHOMA_TO_HVAC_MODE[self.select_state(CORE_ON_OFF_STATE)]
+            return TAHOMA_TO_HVAC_MODE[self.executor.select_state(CORE_ON_OFF_STATE)]
 
     async def async_set_hvac_mode(self, hvac_mode: str) -> None:
         """Set new target hvac mode."""
-        await self.async_execute_command(
+        await self.executor.async_execute_command(
             COMMAND_SET_TOWEL_DRYER_OPERATING_MODE, HVAC_MODE_TO_TAHOMA[hvac_mode]
         )
 
@@ -105,37 +107,37 @@ def preset_modes(self) -> Optional[List[str]]:
     def preset_mode(self) -> Optional[str]:
         """Return the current preset mode, e.g., home, away, temp."""
         return TAHOMA_TO_PRESET_MODE[
-            self.select_state(IO_TOWEL_DRYER_TEMPORARY_STATE_STATE)
+            self.executor.select_state(IO_TOWEL_DRYER_TEMPORARY_STATE_STATE)
         ]
 
     async def async_set_preset_mode(self, preset_mode: str) -> None:
         """Set new preset mode."""
-        await self.async_execute_command(
+        await self.executor.async_execute_command(
             COMMAND_SET_TOWEL_DRYER_TEMPORARY_STATE, PRESET_MODE_TO_TAHOMA[preset_mode]
         )
 
     @property
     def target_temperature(self) -> None:
         """Return the temperature."""
         if self.hvac_mode == HVAC_MODE_AUTO:
-            return self.select_state(IO_EFFECTIVE_TEMPERATURE_SETPOINT_STATE)
+            return self.executor.select_state(IO_EFFECTIVE_TEMPERATURE_SETPOINT_STATE)
         else:
-            return self.select_state(CORE_TARGET_TEMPERATURE_STATE)
+            return self.executor.select_state(CORE_TARGET_TEMPERATURE_STATE)
 
     @property
     def current_temperature(self):
         """Return current temperature."""
-        return self.select_state(CORE_COMFORT_ROOM_TEMPERATURE_STATE)
+        return self.executor.select_state(CORE_COMFORT_ROOM_TEMPERATURE_STATE)
 
     async def async_set_temperature(self, **kwargs) -> None:
         """Set new temperature."""
         temperature = kwargs.get(ATTR_TEMPERATURE)
 
         if self.hvac_mode == HVAC_MODE_AUTO:
-            await self.async_execute_command(
+            await self.executor.async_execute_command(
                 COMMAND_SET_DEROGATED_TARGET_TEMPERATURE, temperature
             )
         else:
-            await self.async_execute_command(
+            await self.executor.async_execute_command(
                 COMMAND_SET_TARGET_TEMPERATURE, temperature
             )