Merge pull request #240 from jaroschek/release/1.8.x

Release 1.8.0

Author: jaroschek

custom_components/myuplink/__init__.py

@@ -15,6 +15,7 @@
 from homeassistant.core import HomeAssistant
 from homeassistant.exceptions import ConfigEntryAuthFailed, ConfigEntryNotReady
 from homeassistant.helpers import aiohttp_client, config_entry_oauth2_flow
+from homeassistant.helpers.device_registry import DeviceEntry
 from homeassistant.helpers.update_coordinator import DataUpdateCoordinator, UpdateFailed
 
 from .api import AsyncConfigEntryAuth, MyUplink
@@ -120,3 +121,10 @@ async def async_migrate_entry(hass: HomeAssistant, entry: ConfigEntry) -> bool:
     )
 
     return True
+
+
+async def async_remove_config_entry_device(
+    hass: HomeAssistant, config_entry: ConfigEntry, device_entry: DeviceEntry
+) -> bool:
+    """Remove a config entry from a device."""
+    return True

custom_components/myuplink/api.py

@@ -7,8 +7,9 @@
 from datetime import datetime, timedelta
 import json
 import logging
+from typing import Any
 
-from aiohttp import ClientResponse, ClientSession
+from aiohttp import ClientResponse, ClientResponseError, ClientSession
 
 from homeassistant.config_entries import ConfigEntry
 from homeassistant.const import (
@@ -26,6 +27,7 @@
     API_VERSION,
     CONF_ADDITIONAL_PARAMETER,
     CONF_ENABLE_SMART_HOME_MODE,
+    CONF_ENABLE_SMART_HOME_ZONE,
     CONF_FETCH_FIRMWARE,
     CONF_FETCH_NOTIFICATIONS,
     CONF_PARAMETER_WHITELIST,
@@ -92,7 +94,7 @@ def type(self) -> str:
     @property
     def valid_until(self) -> datetime:
         """Return datetime value of 'validUntil'."""
-        return datetime(self.raw_data("validUntil"))
+        return datetime.fromisoformat(self.raw_data["validUntil"])
 
 
 class Notification:
@@ -166,23 +168,23 @@ def firmware_id(self) -> int:
         return int(self.raw_data["firmwareId"])
 
     @property
-    def current_version(self) -> str:
+    def current_version(self) -> str | None:
         """Return the current firmware version of the device."""
-        if self.raw_data["currentFwVersion"].strip() == "":
+        if self.raw_data.get("currentFwVersion", "").strip() == "":
             return None
         return self.raw_data["currentFwVersion"].strip()
 
     @property
-    def pending_version(self) -> str:
+    def pending_version(self) -> str | None:
         """Return the pending firmware version of the device."""
-        if self.raw_data["pendingFwVersion"].strip() == "":
+        if self.raw_data.get("pendingFwVersion", "").strip() == "":
             return None
         return self.raw_data["pendingFwVersion"].strip()
 
     @property
-    def desired_version(self) -> str:
+    def desired_version(self) -> str | None:
         """Return the desired firmware version of the device."""
-        if self.raw_data["desiredFwVersion"].strip() == "":
+        if self.raw_data.get("desiredFwVersion", "").strip() == "":
             return None
         return self.raw_data["desiredFwVersion"].strip()
 
@@ -266,15 +268,15 @@ def max_value(self) -> int:
     @property
     def step_value(self) -> int:
         """Return the step value of the parameter."""
-        return self.raw_data["stepValue"]
+        return self.raw_data.get("stepValue", 1)
 
     @property
     def enum_values(self) -> list[dict]:
         """Return the enum values of the parameter."""
         return self.raw_data["enumValues"]
 
     @property
-    def scale_value(self) -> float | None:
+    def scale_value(self) -> float:
         """Return the scale value of the parameter."""
         if self.raw_data["scaleValue"]:
             return float(self.raw_data["scaleValue"])
@@ -287,11 +289,11 @@ def zone_id(self) -> str:
         return self.raw_data["zoneId"]
 
     async def update_parameter(self, value) -> None:
-        """Patch parameter if writable."""
+        """Set parameter value if writable."""
         if not self.is_writable:
             return
         await self.device.system.api.patch_parameter(
-            self.device.id, str(self.id), str(value)
+            self.device.id, str(self.id), value
         )
 
     def get_platform(self) -> Platform:
@@ -316,7 +318,9 @@ def get_platform(self) -> Platform:
         if len(self.enum_values) > 0 and self.is_writable:
             return Platform.SELECT
 
-        if (self.max_value or self.min_value) and self.is_writable:
+        if (
+            self.max_value is not None or self.min_value is not None
+        ) and self.is_writable:
             return Platform.NUMBER
 
         return Platform.SENSOR
@@ -331,24 +335,26 @@ def get_unit(self, parameter_unit) -> str:
                 UnitOfTemperature,
                 UnitOfTime,
             ):
-                for unit in units:
-                    if parameter_unit.lower() == unit.lower():
-                        return str(unit)
+                with suppress(ValueError):
+                    for unit in units:
+                        if parameter_unit.lower() == unit.lower():
+                            return str(unit)
 
         return parameter_unit
 
 
 class Zone:
     """Class that represents a zone object in the myUplink API."""
 
-    def __init__(self, raw_data: dict) -> None:
+    def __init__(self, raw_data: dict, device: Device) -> None:
         """Initialize a zone object."""
         self.raw_data = raw_data
+        self.device = device
 
     @property
     def id(self) -> int:
         """Return the ID of the zone."""
-        return self.raw_data["zoneId"]
+        return int(self.raw_data["zoneId"])
 
     @property
     def name(self) -> str:
@@ -358,62 +364,107 @@ def name(self) -> str:
     @property
     def is_command_only(self) -> bool:
         """Return if the zone is command only."""
-        return self.raw_data["commandOnly"]
+        return bool(self.raw_data["commandOnly"])
 
     @property
-    def supported_modes(self) -> str:
+    def supported_modes(self) -> str | None:
         """Return the supported modes of the zone."""
-        return self.raw_data["supportedModes"]
+        return self.raw_data.get("supportedModes")
 
     @property
     def mode(self) -> str:
         """Return the current mode of the zone."""
         return self.raw_data["mode"]
 
     @property
-    def temperature(self) -> float:
+    def temperature(self) -> float | None:
         """Return the current temperature of the zone."""
-        return self.raw_data["temperature"]
+        return (
+            float(self.raw_data.get("temperature"))
+            if self.raw_data.get("temperature") is not None
+            else None
+        )
 
     @property
-    def setpoint(self) -> float:
+    def setpoint(self) -> float | None:
         """Return the target temperature of the zone."""
-        return self.raw_data["setpoint"]
+        return (
+            float(self.raw_data.get("setpoint"))
+            if self.raw_data.get("setpoint") is not None
+            else None
+        )
 
     @property
-    def setpoint_heating(self) -> float:
+    def setpoint_heating(self) -> float | None:
         """Return the heating setpoint value of the zone."""
-        return self.raw_data["setpointHeat"]
+        return (
+            float(self.raw_data.get("setpointHeat"))
+            if self.raw_data.get("setpointHeat") is not None
+            else None
+        )
 
     @property
-    def setpoint_cooling(self) -> float:
+    def setpoint_cooling(self) -> float | None:
         """Return the cooling setpoint value of the zone."""
-        return self.raw_data["setpointCool"]
+        return (
+            float(self.raw_data.get("setpointCool"))
+            if self.raw_data.get("setpointCool") is not None
+            else None
+        )
 
     @property
-    def setpoint_range_min(self) -> int:
+    def setpoint_range_min(self) -> int | None:
         """Return the minimum temperature range of the zone."""
-        return self.raw_data["setpointRangeMin"]
+        return (
+            int(self.raw_data.get("setpointRangeMin"))
+            if self.raw_data.get("setpointRangeMin") is not None
+            else None
+        )
 
     @property
-    def setpoint_range_max(self) -> int:
+    def setpoint_range_max(self) -> int | None:
         """Return the maximum temperature range of the zone."""
-        return self.raw_data["setpointRangeMax"]
+        return (
+            int(self.raw_data.get("setpointRangeMax"))
+            if self.raw_data.get("setpointRangeMax") is not None
+            else None
+        )
 
     @property
     def is_celsius(self) -> bool:
         """Return if the temperature in the zone is specified as celsius (true) or fahrenheit (false)."""
-        return self.raw_data["isCelsius"]
+        return (
+            bool(self.raw_data.get("isCelsius"))
+            if self.raw_data.get("isCelsius") is not None
+            else True
+        )
 
     @property
-    def indoor_co2(self) -> int:
+    def indoor_co2(self) -> int | None:
         """Return the indoor co2 level of the zone."""
-        return self.raw_data["indoorCo2"]
+        return (
+            int(self.raw_data.get("indoorCo2"))
+            if self.raw_data.get("indoorCo2") is not None
+            else None
+        )
 
     @property
-    def indoor_umidity(self) -> float:
+    def indoor_humidity(self) -> float | None:
         """Return the indoor humidity of the zone."""
-        return self.raw_data["indoorHumidity"]
+        return (
+            float(self.raw_data.get("indoorHumidity"))
+            if self.raw_data.get("indoorHumidity") is not None
+            else None
+        )
+
+    async def update_zone_property(self, property_name: str, value) -> None:
+        """Patch zone if writable."""
+        if self.is_command_only:
+            return
+        await self.device.system.api.patch_zone_property(
+            self.device.id, str(self.id), property_name, value
+        )
+        self.raw_data[property_name] = value
 
 
 class Device:
@@ -463,23 +514,22 @@ def current_firmware_version(self) -> str:
         """Return the current firmware version of the device."""
         if "firmware" in self.raw_data:
             return self.raw_data["firmware"]["currentFwVersion"]
-
-        return self.raw_data["currentFwVersion"]
+        return self.raw_data.get("currentFwVersion", "N/A")
 
     @property
     def desired_firmware_version(self) -> str:
         """Return the desired firmware version of the device."""
         if "firmware" in self.raw_data:
             return self.raw_data["firmware"]["desiredFwVersion"]
-
         return "?"
 
     async def async_fetch_data(self) -> None:
         """Fetch data from myUplink API."""
         self.parameters = await self.system.api.get_parameters(self)
         if self.system.api.entry.options.get(CONF_FETCH_FIRMWARE, True):
             self.firmware_info = await self.system.api.get_firmware_info(self)
-        # self.zones = await self.system.api.get_zones(self.id)
+        if self.system.api.entry.options.get(CONF_ENABLE_SMART_HOME_ZONE, True):
+            self.zones = await self.system.api.get_zones(self)
 
 
 class System:
@@ -516,7 +566,7 @@ def security_level(self) -> str:
     @property
     def has_alaram(self) -> bool:
         """Return if the system has an alaram."""
-        return self.raw_data["has_alaram"]
+        return self.raw_data.get("hasAlarm", False)
 
     async def async_fetch_data(self) -> None:
         """Fetch data from myUplink API."""
@@ -663,7 +713,9 @@ async def get_premium_manage(self, system: System) -> bool:
 
         try:
             async with self.lock, self.throttle:
-                resp = await self.auth.request("get", f"systems/{system.id}/subscriptions")
+                resp = await self.auth.request(
+                    "get", f"systems/{system.id}/subscriptions"
+                )
 
             # This will raise an exception for 4xx or 5xx errors
             resp.raise_for_status()
@@ -674,9 +726,11 @@ async def get_premium_manage(self, system: System) -> bool:
                     if Subscription(subscription).type == "manage":
                         return True
 
-        except Exception as err:
+        except ClientResponseError as err:
             # We catch the 500 error (and others) here so the integration keeps running
-            _LOGGER.error("Error fetching subscriptions for system %s: %s", system.id, err)
+            _LOGGER.error(
+                "Error fetching subscriptions for system %s: %s", system.id, err
+            )
 
         return False
 
@@ -781,17 +835,17 @@ async def get_parameters(self, device: Device) -> list[Parameter]:
 
         return list(unique_parameters.values())
 
-    async def get_zones(self, device_id) -> list[Zone]:
+    async def get_zones(self, device: Device) -> list[Zone]:
         """Return all smart home zones for a device."""
-        _LOGGER.debug("Fetch zones for device %s", device_id)
+        _LOGGER.debug("Fetch zones for device %s", device.id)
         async with self.lock, self.throttle:
             resp = await self.auth.request(
-                "get", f"devices/{device_id}/smart-home-zones", headers=self.header
+                "get", f"devices/{device.id}/smart-home-zones", headers=self.header
             )
         resp.raise_for_status()
-        return [Zone(zone) for zone in await resp.json()]
+        return [Zone(zone, device) for zone in await resp.json()]
 
-    async def patch_parameter(self, device_id, parameter_id: str, value: str) -> bool:
+    async def patch_parameter(self, device_id, parameter_id: str, value: Any) -> bool:
         """Update the value of a parameter for a device."""
         _LOGGER.debug(
             "Patch parameter %s for device %s with value %s",
@@ -809,6 +863,27 @@ async def patch_parameter(self, device_id, parameter_id: str, value: str) -> boo
         resp.raise_for_status()
         return resp.status == 200
 
+    async def patch_zone_property(
+        self, device_id, zone_id: str, property_name: str, value: str
+    ) -> bool:
+        """Update the value of a zone property for a device."""
+        _LOGGER.debug(
+            "Patch property %s for zone %s of device %s with value %s",
+            property_name,
+            zone_id,
+            device_id,
+            value,
+        )
+        async with self.lock, self.throttle:
+            resp = await self.auth.request(
+                "patch",
+                f"devices/{device_id}/zones/{zone_id}",
+                data=json.dumps({property_name: value}),
+                headers={"Content-Type": "application/json-patch+json"},
+            )
+        resp.raise_for_status()
+        return resp.status == 200
+
     def parse_int_keys(self, dct):
         """Parse object keys into integers."""
         rval = {}