Merge pull request #98 from jwillemsen/jwi-testsensors

First draft code for sensor tests

Author: jwillemsen

.pre-commit-config.yaml

@@ -6,15 +6,13 @@ repos:
       - id: check-yaml
       - id: end-of-file-fixer
       - id: trailing-whitespace
-  - repo: local
+  - repo: https://github.com/astral-sh/ruff-pre-commit
+    rev: v0.1.14
     hooks:
-      - id: black
-        name: black
-        entry: black
-        language: system
-        types: [python]
-        require_serial: true
-  - repo: https://github.com/pre-commit/mirrors-prettier
-    rev: v3.1.0
+      - id: ruff
+        args: [--fix]
+      - id: ruff-format
+  - repo: https://github.com/asottile/reorder-python-imports
+    rev: v3.12.0
     hooks:
-      - id: prettier
+    -   id: reorder-python-imports

custom_components/daikin_onecta/__init__.py

@@ -1,15 +1,14 @@
 """Platform for the Daikin AC."""
-
 import asyncio
 import logging
 
 from aiohttp import ClientError
 from homeassistant.config_entries import ConfigEntry
 from homeassistant.config_entries import SOURCE_IMPORT
 from homeassistant.const import SERVICE_RELOAD
+from homeassistant.core import HomeAssistant
 from homeassistant.exceptions import ConfigEntryNotReady
 from homeassistant.helpers import config_entry_oauth2_flow
-from homeassistant.core import HomeAssistant
 
 from .const import COORDINATOR
 from .const import DAIKIN_API

custom_components/daikin_onecta/application_credentials.py

@@ -1,5 +1,6 @@
 from homeassistant.components.application_credentials import AuthorizationServer
 from homeassistant.core import HomeAssistant
+
 from .const import OAUTH2_AUTHORIZE
 from .const import OAUTH2_TOKEN
 

custom_components/daikin_onecta/climate.py

@@ -1,5 +1,4 @@
 """Support for the Daikin HVAC."""
-
 import logging
 import re
 
@@ -9,7 +8,6 @@
 from homeassistant.components.climate import PLATFORM_SCHEMA
 from homeassistant.components.climate.const import ATTR_HVAC_MODE
 from homeassistant.components.climate.const import ClimateEntityFeature
-from homeassistant.components.climate.const import FAN_AUTO
 from homeassistant.components.climate.const import HVACMode
 from homeassistant.components.climate.const import PRESET_AWAY
 from homeassistant.components.climate.const import PRESET_BOOST
@@ -74,9 +72,11 @@ async def async_setup_entry(hass, entry, async_add_entities):
         device_model = device.daikin_data["deviceModel"]
         supported_management_point_types = {"climateControl"}
         managementPoints = device.daikin_data.get("managementPoints", [])
+        embedded_id = ""
         for management_point in managementPoints:
             management_point_type = management_point["managementPointType"]
             if management_point_type in supported_management_point_types:
+                embedded_id = management_point.get("embeddedId")
                 # Check if we have a temperatureControl
                 temperatureControl = management_point.get("temperatureControl")
                 if temperatureControl is not None:
@@ -88,7 +88,10 @@ async def async_setup_entry(hass, entry, async_add_entities):
         modes = list(dict.fromkeys(modes))
         _LOGGER.info("Climate: Device '%s' has modes %s", device_model, modes)
         for mode in modes:
-            async_add_entities([DaikinClimate(device, mode, coordinator)], update_before_add=False)
+            async_add_entities(
+                [DaikinClimate(device, mode, coordinator, embedded_id)],
+                update_before_add=False,
+            )
 
 
 class DaikinClimate(CoordinatorEntity, ClimateEntity):
@@ -98,7 +101,7 @@ class DaikinClimate(CoordinatorEntity, ClimateEntity):
 
     # Setpoint is the setpoint string under
     # temperatureControl/value/operationsModes/mode/setpoints, for example roomTemperature/leavingWaterOffset
-    def __init__(self, device, setpoint, coordinator):
+    def __init__(self, device, setpoint, coordinator, embedded_id):
         """Initialize the climate device."""
         super().__init__(coordinator)
         _LOGGER.info(
@@ -107,9 +110,13 @@ def __init__(self, device, setpoint, coordinator):
             setpoint,
         )
         self._device = device
+        self._embedded_id = embedded_id
         self._setpoint = setpoint
-        self._attr_supported_features = self.get_supported_features()
         self._attr_temperature_unit = UnitOfTemperature.CELSIUS
+        self.update_state()
+
+    def update_state(self) -> None:
+        self._attr_supported_features = self.get_supported_features()
         self._attr_current_temperature = self.get_current_temperature()
         self._attr_max_temp = self.get_max_temp()
         self._attr_min_temp = self.get_min_temp()
@@ -126,25 +133,9 @@ def __init__(self, device, setpoint, coordinator):
 
     @callback
     def _handle_coordinator_update(self) -> None:
-        self._attr_supported_features = self.get_supported_features()
-        self._attr_current_temperature = self.get_current_temperature()
-        self._attr_max_temp = self.get_max_temp()
-        self._attr_min_temp = self.get_min_temp()
-        self._attr_target_temperature_step = self.get_target_temperature_step()
-        self._attr_target_temperature = self.get_target_temperature()
-        self._attr_hvac_modes = self.get_hvac_modes()
-        self._attr_swing_modes = self.get_swing_modes()
-        self._attr_preset_modes = self.get_preset_modes()
-        self._attr_fan_modes = self.get_fan_modes()
-        self._attr_hvac_mode = self.get_hvac_mode()
-        self._attr_swing_mode = self.get_swing_mode()
-        self._attr_preset_mode = self.get_preset_mode()
-        self._attr_fan_mode = self.get_fan_mode()
+        self.update_state()
         self.async_write_ha_state()
 
-    async def _set(self, settings):
-        raise NotImplementedError
-
     def climate_control(self):
         cc = None
         supported_management_point_types = {"climateControl"}
@@ -179,29 +170,6 @@ def setpoint(self):
             )
         return setpoint
 
-    # Return the dictionary fanControl for the current operationMode
-    def fan_control(self):
-        fancontrol = None
-        supported_management_point_types = {"climateControl"}
-        if self._device.daikin_data["managementPoints"] is not None:
-            for management_point in self._device.daikin_data["managementPoints"]:
-                management_point_type = management_point["managementPointType"]
-                if management_point_type in supported_management_point_types:
-                    # Check if we have a temperatureControl
-                    temperatureControl = management_point.get("fanControl")
-                    _LOGGER.info("Climate: Device fanControl %s", temperatureControl)
-                    if temperatureControl is not None:
-                        operationMode = management_point.get("operationMode").get("value")
-                        fancontrol = temperatureControl["value"]["operationModes"][operationMode].get(self._setpoint)
-                        _LOGGER.info(
-                            "Device '%s': %s operation mode %s has fanControl %s",
-                            self._device.name,
-                            self._setpoint,
-                            operationMode,
-                            fancontrol,
-                        )
-        return fancontrol
-
     def sensory_data(self):
         sensoryData = None
         supported_management_point_types = {"climateControl"}
@@ -226,11 +194,6 @@ def sensory_data(self):
     def translation_key(self) -> str:
         return "daikin_onecta"
 
-    @property
-    def embedded_id(self):
-        cc = self.climate_control()
-        return cc["embeddedId"]
-
     @property
     def available(self):
         """Return the availability of the underlying device."""
@@ -355,7 +318,7 @@ async def async_set_temperature(self, **kwargs):
             value = kwargs[ATTR_TEMPERATURE]
             res = await self._device.set_path(
                 self._device.getId(),
-                self.embedded_id,
+                self._embedded_id,
                 "temperatureControl",
                 f"/operationModes/{omv}/setpoints/{self._setpoint}",
                 value,
@@ -411,7 +374,7 @@ async def async_set_hvac_mode(self, hvac_mode):
 
         # Only set the on/off to Daikin when we need to change it
         if on_off_mode is not None:
-            result &= await self._device.set_path(self._device.getId(), self.embedded_id, "onOffMode", "", on_off_mode)
+            result &= await self._device.set_path(self._device.getId(), self._embedded_id, "onOffMode", "", on_off_mode)
             if result is False:
                 _LOGGER.warning(
                     "Device '%s' problem setting onOffMode to %s",
@@ -427,7 +390,7 @@ async def async_set_hvac_mode(self, hvac_mode):
             if operation_mode != cc["operationMode"]["value"]:
                 result &= await self._device.set_path(
                     self._device.getId(),
-                    self.embedded_id,
+                    self._embedded_id,
                     "operationMode",
                     "",
                     operation_mode,
@@ -442,22 +405,9 @@ async def async_set_hvac_mode(self, hvac_mode):
                     cc["operationMode"]["value"] = operation_mode
 
         if result is True:
-            self._attr_hvac_mode = hvac_mode
             # When switching hvac mode it could be that we can set min/max/target/etc
             # which we couldn't set with a previous hvac mode
-            self._attr_supported_features = self.get_supported_features()
-            self._attr_current_temperature = self.get_current_temperature()
-            self._attr_max_temp = self.get_max_temp()
-            self._attr_min_temp = self.get_min_temp()
-            self._attr_target_temperature_step = self.get_target_temperature_step()
-            self._attr_target_temperature = self.get_target_temperature()
-            self._attr_swing_modes = self.get_swing_modes()
-            self._attr_preset_modes = self.get_preset_modes()
-            self._attr_fan_modes = self.get_fan_modes()
-            self._attr_swing_mode = self.get_swing_mode()
-            self._attr_preset_mode = self.get_preset_mode()
-            self._attr_fan_mode = self.get_fan_mode()
-
+            self.update_state()
             self.async_write_ha_state()
 
         return result
@@ -522,7 +472,7 @@ async def async_set_fan_mode(self, fan_mode):
         if fan_mode.isnumeric():
             res = await self._device.set_path(
                 self._device.getId(),
-                self.embedded_id,
+                self._embedded_id,
                 "fanControl",
                 f"/operationModes/{operationmode}/fanSpeed/currentMode",
                 "fixed",
@@ -536,7 +486,7 @@ async def async_set_fan_mode(self, fan_mode):
             new_fixed_mode = int(fan_mode)
             res &= await self._device.set_path(
                 self._device.getId(),
-                self.embedded_id,
+                self._embedded_id,
                 "fanControl",
                 f"/operationModes/{operationmode}/fanSpeed/modes/fixed",
                 new_fixed_mode,
@@ -550,7 +500,7 @@ async def async_set_fan_mode(self, fan_mode):
         else:
             res = await self._device.set_path(
                 self._device.getId(),
-                self.embedded_id,
+                self._embedded_id,
                 "fanControl",
                 f"/operationModes/{operationmode}/fanSpeed/currentMode",
                 fan_mode,
@@ -671,7 +621,7 @@ async def async_set_swing_mode(self, swing_mode):
                         new_h_mode = "swing"
                     res &= await self._device.set_path(
                         self._device.getId(),
-                        self.embedded_id,
+                        self._embedded_id,
                         "fanControl",
                         f"/operationModes/{operation_mode}/fanDirection/horizontal/currentMode",
                         new_h_mode,
@@ -699,7 +649,7 @@ async def async_set_swing_mode(self, swing_mode):
                         new_v_mode = "windNice"
                     res &= await self._device.set_path(
                         self._device.getId(),
-                        self.embedded_id,
+                        self._embedded_id,
                         "fanControl",
                         f"/operationModes/{operation_mode}/fanDirection/vertical/currentMode",
                         new_v_mode,
@@ -735,7 +685,7 @@ async def async_set_preset_mode(self, preset_mode):
 
         if self.preset_mode != PRESET_NONE:
             current_mode = HA_PRESET_TO_DAIKIN[self.preset_mode]
-            result &= await self._device.set_path(self._device.getId(), self.embedded_id, current_mode, "", "off")
+            result &= await self._device.set_path(self._device.getId(), self._embedded_id, current_mode, "", "off")
             if result is False:
                 _LOGGER.warning(
                     "Device '%s' problem setting %s to off",
@@ -747,7 +697,7 @@ async def async_set_preset_mode(self, preset_mode):
             if self.hvac_mode == HVACMode.OFF and preset_mode == PRESET_BOOST:
                 result &= await self.async_turn_on()
 
-            result &= await self._device.set_path(self._device.getId(), self.embedded_id, new_daikin_mode, "", "on")
+            result &= await self._device.set_path(self._device.getId(), self._embedded_id, new_daikin_mode, "", "on")
             if result is False:
                 _LOGGER.warning(
                     "Device '%s' problem setting %s to on",
@@ -785,7 +735,7 @@ async def async_turn_on(self):
         cc = self.climate_control()
         result = True
         if cc["onOffMode"]["value"] == "off":
-            result &= await self._device.set_path(self._device.getId(), self.embedded_id, "onOffMode", "", "on")
+            result &= await self._device.set_path(self._device.getId(), self._embedded_id, "onOffMode", "", "on")
             if result is False:
                 _LOGGER.error("Device '%s' problem setting onOffMode to on", self._device.name)
             else:
@@ -805,7 +755,7 @@ async def async_turn_off(self):
         cc = self.climate_control()
         result = True
         if cc["onOffMode"]["value"] == "on":
-            result &= await self._device.set_path(self._device.getId(), self.embedded_id, "onOffMode", "", "off")
+            result &= await self._device.set_path(self._device.getId(), self._embedded_id, "onOffMode", "", "off")
             if result is False:
                 _LOGGER.error("Device '%s' problem setting onOffMode to off", self._device.name)
             else:

custom_components/daikin_onecta/config_flow.py

@@ -1,5 +1,4 @@
 """Config flow for the Daikin platform."""
-
 import logging
 from collections.abc import Mapping
 from typing import Any
@@ -20,7 +19,7 @@
 
 
 class OptionsFlowHandler(config_entries.OptionsFlow):
-    """Config flow options handler for myenergi."""
+    """Config flow options handler for daikin_onecta ."""
 
     def __init__(self, config_entry):
         """Initialize HACS options flow."""

custom_components/daikin_onecta/const.py

@@ -1,5 +1,4 @@
 """Constants for Daikin Oncecta."""
-
 from homeassistant.components.sensor import CONF_STATE_CLASS
 from homeassistant.components.sensor import SensorDeviceClass
 from homeassistant.components.sensor import SensorStateClass

custom_components/daikin_onecta/coordinator.py

@@ -1,5 +1,4 @@
 """Coordinator for Daikin Onecta integration."""
-
 from __future__ import annotations
 
 import logging
@@ -25,7 +24,12 @@ def __init__(self, hass: HomeAssistant, config_entry: ConfigEntry) -> None:
         """Initialize."""
         self.options = config_entry.options
 
-        super().__init__(hass, _LOGGER, name=DOMAIN, update_interval=self.determine_update_interval(hass))
+        super().__init__(
+            hass,
+            _LOGGER,
+            name=DOMAIN,
+            update_interval=self.determine_update_interval(hass),
+        )
 
         _LOGGER.info(
             "Daikin coordinator initialized with %s interval.",

custom_components/daikin_onecta/daikin_api.py

@@ -1,5 +1,4 @@
 """Platform for the Daikin AC."""
-
 import asyncio
 import functools
 import logging
@@ -13,7 +12,6 @@
 
 from .const import DAIKIN_DEVICES
 from .const import DOMAIN
-from .daikin_base import Appliance
 
 _LOGGER = logging.getLogger(__name__)
 
@@ -40,7 +38,14 @@ def __init__(
         self._last_patch_call = datetime.min
 
         # Store the limits as member so that we can add these to the diagnostics
-        self.rate_limits = {"minute": 0, "day": 0, "remaining_minutes": 0, "remaining_day": 0, "retry_after": 0, "ratelimit_reset": 0}
+        self.rate_limits = {
+            "minute": 0,
+            "day": 0,
+            "remaining_minutes": 0,
+            "remaining_day": 0,
+            "retry_after": 0,
+            "ratelimit_reset": 0,
+        }
 
         # The following lock is used to serialize http requests to Daikin cloud
         # to prevent receiving old settings while a PATCH is ongoing.

custom_components/daikin_onecta/daikin_base.py

@@ -1,5 +1,4 @@
 """Pydaikin base appliance, represent a Daikin device."""
-
 import logging
 
 from .device import DaikinOnectaDevice