Wallbox Integration, Reduce API impact by limiting the amount of API calls made (home-assistant#147618)

Author: hesselonline

homeassistant/components/wallbox/const.py

@@ -22,6 +22,8 @@
 CHARGER_CURRENT_VERSION_KEY = "currentVersion"
 CHARGER_CURRENCY_KEY = "currency"
 CHARGER_DATA_KEY = "config_data"
+CHARGER_DATA_POST_L1_KEY = "data"
+CHARGER_DATA_POST_L2_KEY = "chargerData"
 CHARGER_DEPOT_PRICE_KEY = "depot_price"
 CHARGER_ENERGY_PRICE_KEY = "energy_price"
 CHARGER_FEATURES_KEY = "features"
@@ -32,7 +34,9 @@
 CHARGER_SOFTWARE_KEY = "software"
 CHARGER_MAX_AVAILABLE_POWER_KEY = "max_available_power"
 CHARGER_MAX_CHARGING_CURRENT_KEY = "max_charging_current"
+CHARGER_MAX_CHARGING_CURRENT_POST_KEY = "maxChargingCurrent"
 CHARGER_MAX_ICP_CURRENT_KEY = "icp_max_current"
+CHARGER_MAX_ICP_CURRENT_POST_KEY = "maxAvailableCurrent"
 CHARGER_PAUSE_RESUME_KEY = "paused"
 CHARGER_LOCKED_UNLOCKED_KEY = "locked"
 CHARGER_NAME_KEY = "name"

homeassistant/components/wallbox/coordinator.py

@@ -14,18 +14,21 @@
 from homeassistant.config_entries import ConfigEntry
 from homeassistant.core import HomeAssistant
 from homeassistant.exceptions import ConfigEntryAuthFailed, HomeAssistantError
-from homeassistant.helpers.update_coordinator import DataUpdateCoordinator
+from homeassistant.helpers.update_coordinator import DataUpdateCoordinator, UpdateFailed
 
 from .const import (
     CHARGER_CURRENCY_KEY,
     CHARGER_DATA_KEY,
+    CHARGER_DATA_POST_L1_KEY,
+    CHARGER_DATA_POST_L2_KEY,
     CHARGER_ECO_SMART_KEY,
     CHARGER_ECO_SMART_MODE_KEY,
     CHARGER_ECO_SMART_STATUS_KEY,
     CHARGER_ENERGY_PRICE_KEY,
     CHARGER_FEATURES_KEY,
     CHARGER_LOCKED_UNLOCKED_KEY,
     CHARGER_MAX_CHARGING_CURRENT_KEY,
+    CHARGER_MAX_CHARGING_CURRENT_POST_KEY,
     CHARGER_MAX_ICP_CURRENT_KEY,
     CHARGER_PLAN_KEY,
     CHARGER_POWER_BOOST_KEY,
@@ -192,10 +195,10 @@ def _get_data(self) -> dict[str, Any]:
             return data  # noqa: TRY300
         except requests.exceptions.HTTPError as wallbox_connection_error:
             if wallbox_connection_error.response.status_code == 429:
-                raise HomeAssistantError(
+                raise UpdateFailed(
                     translation_domain=DOMAIN, translation_key="too_many_requests"
                 ) from wallbox_connection_error
-            raise HomeAssistantError(
+            raise UpdateFailed(
                 translation_domain=DOMAIN, translation_key="api_failed"
             ) from wallbox_connection_error
 
@@ -204,10 +207,19 @@ async def _async_update_data(self) -> dict[str, Any]:
         return await self.hass.async_add_executor_job(self._get_data)
 
     @_require_authentication
-    def _set_charging_current(self, charging_current: float) -> None:
+    def _set_charging_current(
+        self, charging_current: float
+    ) -> dict[str, dict[str, dict[str, Any]]]:
         """Set maximum charging current for Wallbox."""
         try:
-            self._wallbox.setMaxChargingCurrent(self._station, charging_current)
+            result = self._wallbox.setMaxChargingCurrent(
+                self._station, charging_current
+            )
+            data = self.data
+            data[CHARGER_MAX_CHARGING_CURRENT_KEY] = result[CHARGER_DATA_POST_L1_KEY][
+                CHARGER_DATA_POST_L2_KEY
+            ][CHARGER_MAX_CHARGING_CURRENT_POST_KEY]
+            return data  # noqa: TRY300
         except requests.exceptions.HTTPError as wallbox_connection_error:
             if wallbox_connection_error.response.status_code == 403:
                 raise InvalidAuth from wallbox_connection_error
@@ -221,16 +233,19 @@ def _set_charging_current(self, charging_current: float) -> None:
 
     async def async_set_charging_current(self, charging_current: float) -> None:
         """Set maximum charging current for Wallbox."""
-        await self.hass.async_add_executor_job(
+        data = await self.hass.async_add_executor_job(
             self._set_charging_current, charging_current
         )
-        await self.async_request_refresh()
+        self.async_set_updated_data(data)
 
     @_require_authentication
-    def _set_icp_current(self, icp_current: float) -> None:
+    def _set_icp_current(self, icp_current: float) -> dict[str, Any]:
         """Set maximum icp current for Wallbox."""
         try:
-            self._wallbox.setIcpMaxCurrent(self._station, icp_current)
+            result = self._wallbox.setIcpMaxCurrent(self._station, icp_current)
+            data = self.data
+            data[CHARGER_MAX_ICP_CURRENT_KEY] = result[CHARGER_MAX_ICP_CURRENT_KEY]
+            return data  # noqa: TRY300
         except requests.exceptions.HTTPError as wallbox_connection_error:
             if wallbox_connection_error.response.status_code == 403:
                 raise InvalidAuth from wallbox_connection_error
@@ -244,14 +259,19 @@ def _set_icp_current(self, icp_current: float) -> None:
 
     async def async_set_icp_current(self, icp_current: float) -> None:
         """Set maximum icp current for Wallbox."""
-        await self.hass.async_add_executor_job(self._set_icp_current, icp_current)
-        await self.async_request_refresh()
+        data = await self.hass.async_add_executor_job(
+            self._set_icp_current, icp_current
+        )
+        self.async_set_updated_data(data)
 
     @_require_authentication
-    def _set_energy_cost(self, energy_cost: float) -> None:
+    def _set_energy_cost(self, energy_cost: float) -> dict[str, Any]:
         """Set energy cost for Wallbox."""
         try:
-            self._wallbox.setEnergyCost(self._station, energy_cost)
+            result = self._wallbox.setEnergyCost(self._station, energy_cost)
+            data = self.data
+            data[CHARGER_ENERGY_PRICE_KEY] = result[CHARGER_ENERGY_PRICE_KEY]
+            return data  # noqa: TRY300
         except requests.exceptions.HTTPError as wallbox_connection_error:
             if wallbox_connection_error.response.status_code == 429:
                 raise HomeAssistantError(
@@ -263,17 +283,24 @@ def _set_energy_cost(self, energy_cost: float) -> None:
 
     async def async_set_energy_cost(self, energy_cost: float) -> None:
         """Set energy cost for Wallbox."""
-        await self.hass.async_add_executor_job(self._set_energy_cost, energy_cost)
-        await self.async_request_refresh()
+        data = await self.hass.async_add_executor_job(
+            self._set_energy_cost, energy_cost
+        )
+        self.async_set_updated_data(data)
 
     @_require_authentication
-    def _set_lock_unlock(self, lock: bool) -> None:
+    def _set_lock_unlock(self, lock: bool) -> dict[str, dict[str, dict[str, Any]]]:
         """Set wallbox to locked or unlocked."""
         try:
             if lock:
-                self._wallbox.lockCharger(self._station)
+                result = self._wallbox.lockCharger(self._station)
             else:
-                self._wallbox.unlockCharger(self._station)
+                result = self._wallbox.unlockCharger(self._station)
+            data = self.data
+            data[CHARGER_LOCKED_UNLOCKED_KEY] = result[CHARGER_DATA_POST_L1_KEY][
+                CHARGER_DATA_POST_L2_KEY
+            ][CHARGER_LOCKED_UNLOCKED_KEY]
+            return data  # noqa: TRY300
         except requests.exceptions.HTTPError as wallbox_connection_error:
             if wallbox_connection_error.response.status_code == 403:
                 raise InvalidAuth from wallbox_connection_error
@@ -287,8 +314,8 @@ def _set_lock_unlock(self, lock: bool) -> None:
 
     async def async_set_lock_unlock(self, lock: bool) -> None:
         """Set wallbox to locked or unlocked."""
-        await self.hass.async_add_executor_job(self._set_lock_unlock, lock)
-        await self.async_request_refresh()
+        data = await self.hass.async_add_executor_job(self._set_lock_unlock, lock)
+        self.async_set_updated_data(data)
 
     @_require_authentication
     def _pause_charger(self, pause: bool) -> None:

homeassistant/components/wallbox/lock.py

@@ -7,7 +7,6 @@
 from homeassistant.components.lock import LockEntity, LockEntityDescription
 from homeassistant.config_entries import ConfigEntry
 from homeassistant.core import HomeAssistant
-from homeassistant.exceptions import HomeAssistantError, PlatformNotReady
 from homeassistant.helpers.entity_platform import AddConfigEntryEntitiesCallback
 
 from .const import (
@@ -16,7 +15,7 @@
     CHARGER_SERIAL_NUMBER_KEY,
     DOMAIN,
 )
-from .coordinator import InvalidAuth, WallboxCoordinator
+from .coordinator import WallboxCoordinator
 from .entity import WallboxEntity
 
 LOCK_TYPES: dict[str, LockEntityDescription] = {
@@ -34,16 +33,6 @@ async def async_setup_entry(
 ) -> None:
     """Create wallbox lock entities in HASS."""
     coordinator: WallboxCoordinator = hass.data[DOMAIN][entry.entry_id]
-    # Check if the user is authorized to lock, if so, add lock component
-    try:
-        await coordinator.async_set_lock_unlock(
-            coordinator.data[CHARGER_LOCKED_UNLOCKED_KEY]
-        )
-    except InvalidAuth:
-        return
-    except HomeAssistantError as exc:
-        raise PlatformNotReady from exc
-
     async_add_entities(
         WallboxLock(coordinator, description)
         for ent in coordinator.data

homeassistant/components/wallbox/number.py

@@ -12,7 +12,6 @@
 from homeassistant.components.number import NumberEntity, NumberEntityDescription
 from homeassistant.config_entries import ConfigEntry
 from homeassistant.core import HomeAssistant
-from homeassistant.exceptions import HomeAssistantError, PlatformNotReady
 from homeassistant.helpers.entity_platform import AddConfigEntryEntitiesCallback
 
 from .const import (
@@ -26,7 +25,7 @@
     CHARGER_SERIAL_NUMBER_KEY,
     DOMAIN,
 )
-from .coordinator import InvalidAuth, WallboxCoordinator
+from .coordinator import WallboxCoordinator
 from .entity import WallboxEntity
 
 
@@ -86,16 +85,6 @@ async def async_setup_entry(
 ) -> None:
     """Create wallbox number entities in HASS."""
     coordinator: WallboxCoordinator = hass.data[DOMAIN][entry.entry_id]
-    # Check if the user has sufficient rights to change values, if so, add number component:
-    try:
-        await coordinator.async_set_charging_current(
-            coordinator.data[CHARGER_MAX_CHARGING_CURRENT_KEY]
-        )
-    except InvalidAuth:
-        return
-    except HomeAssistantError as exc:
-        raise PlatformNotReady from exc
-
     async_add_entities(
         WallboxNumber(coordinator, entry, description)
         for ent in coordinator.data

tests/components/wallbox/test_lock.py

@@ -12,10 +12,10 @@
 
 from . import (
     authorisation_response,
+    http_403_error,
+    http_404_error,
     http_429_error,
     setup_integration,
-    setup_integration_platform_not_ready,
-    setup_integration_read_only,
 )
 from .const import MOCK_LOCK_ENTITY_ID
 
@@ -38,11 +38,15 @@ async def test_wallbox_lock_class(hass: HomeAssistant, entry: MockConfigEntry) -
         ),
         patch(
             "homeassistant.components.wallbox.Wallbox.lockCharger",
-            new=Mock(return_value={CHARGER_LOCKED_UNLOCKED_KEY: False}),
+            new=Mock(
+                return_value={"data": {"chargerData": {CHARGER_LOCKED_UNLOCKED_KEY: 1}}}
+            ),
         ),
         patch(
             "homeassistant.components.wallbox.Wallbox.unlockCharger",
-            new=Mock(return_value={CHARGER_LOCKED_UNLOCKED_KEY: False}),
+            new=Mock(
+                return_value={"data": {"chargerData": {CHARGER_LOCKED_UNLOCKED_KEY: 0}}}
+            ),
         ),
     ):
         await hass.services.async_call(
@@ -129,6 +133,52 @@ async def test_wallbox_lock_class_connection_error(
             new=Mock(side_effect=http_429_error),
         ),
         pytest.raises(HomeAssistantError),
+    ):
+        await hass.services.async_call(
+            "lock",
+            SERVICE_LOCK,
+            {
+                ATTR_ENTITY_ID: MOCK_LOCK_ENTITY_ID,
+            },
+            blocking=True,
+        )
+    with (
+        patch(
+            "homeassistant.components.wallbox.Wallbox.authenticate",
+            new=Mock(return_value=authorisation_response),
+        ),
+        patch(
+            "homeassistant.components.wallbox.Wallbox.lockCharger",
+            new=Mock(side_effect=http_403_error),
+        ),
+        patch(
+            "homeassistant.components.wallbox.Wallbox.unlockCharger",
+            new=Mock(side_effect=http_403_error),
+        ),
+        pytest.raises(HomeAssistantError),
+    ):
+        await hass.services.async_call(
+            "lock",
+            SERVICE_UNLOCK,
+            {
+                ATTR_ENTITY_ID: MOCK_LOCK_ENTITY_ID,
+            },
+            blocking=True,
+        )
+    with (
+        patch(
+            "homeassistant.components.wallbox.Wallbox.authenticate",
+            new=Mock(return_value=authorisation_response),
+        ),
+        patch(
+            "homeassistant.components.wallbox.Wallbox.lockCharger",
+            new=Mock(side_effect=http_404_error),
+        ),
+        patch(
+            "homeassistant.components.wallbox.Wallbox.unlockCharger",
+            new=Mock(side_effect=http_404_error),
+        ),
+        pytest.raises(HomeAssistantError),
     ):
         await hass.services.async_call(
             "lock",
@@ -138,27 +188,3 @@ async def test_wallbox_lock_class_connection_error(
             },
             blocking=True,
         )
-
-
-async def test_wallbox_lock_class_authentication_error(
-    hass: HomeAssistant, entry: MockConfigEntry
-) -> None:
-    """Test wallbox lock not loaded on authentication error."""
-
-    await setup_integration_read_only(hass, entry)
-
-    state = hass.states.get(MOCK_LOCK_ENTITY_ID)
-
-    assert state is None
-
-
-async def test_wallbox_lock_class_platform_not_ready(
-    hass: HomeAssistant, entry: MockConfigEntry
-) -> None:
-    """Test wallbox lock not loaded on authentication error."""
-
-    await setup_integration_platform_not_ready(hass, entry)
-
-    state = hass.states.get(MOCK_LOCK_ENTITY_ID)
-
-    assert state is None