blebox-uniapi 2.5.6__tar.gz → 2.5.8__tar.gz

{blebox_uniapi-2.5.6 → blebox_uniapi-2.5.8}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: blebox_uniapi
-Version: 2.5.6
+Version: 2.5.8
 Summary: Python API for accessing BleBox smart home devices
 Home-page: https://github.com/blebox/blebox_uniapi
 Author: BleBox

{blebox_uniapi-2.5.6 → blebox_uniapi-2.5.8}/blebox_uniapi/__init__.py

@@ -2,4 +2,4 @@
 
 __author__ = """BleBox"""
 __email__ = "opensource@blebox.eu"
-__version__ = "2.5.6"
+__version__ = "2.5.8"

{blebox_uniapi-2.5.6 → blebox_uniapi-2.5.8}/blebox_uniapi/box.py

@@ -387,7 +387,10 @@ class Box:
         await self._session.async_api_get_ota("/api/ota/check")
         for _ in range(3):
             await asyncio.sleep(1)
-            response = await self._session.async_api_get("/info")
+            try:
+                response = await self._session.async_api_get("/api/device/state")
+            except HttpError:
+                response = await self._session.async_api_get("/info")
             if response is None:
                 raise UnsupportedBoxResponse("Device returned non-JSON response")
             response = response.get("device", response)

{blebox_uniapi-2.5.6 → blebox_uniapi-2.5.8}/blebox_uniapi/box_types.py

@@ -191,6 +191,7 @@ BOX_TYPE_CONF: dict[str, dict[int, dict[str, Any]]] = {
                         "minimum": "thermo.minimumTemp",
                         "maximum": "thermo.maximumTemp",
                         "temperature": lambda x: f"sensors[?id == `{x}`]|[0]|value",
+                        "temperature.state": lambda x: f"sensors[?id == `{x}`]|[0]|state",
                         "state": "thermo.state",
                         "mode": "thermo.mode",
                         "safetySensorId": "thermo.safetyTempSensor.sensorId",
@@ -203,6 +204,7 @@ BOX_TYPE_CONF: dict[str, dict[int, dict[str, Any]]] = {
                     "temperature",
                     {
                         "temperature": lambda x: f"sensors[?id == `{x}`]|[0]|value",
+                        "temperature.state": lambda x: f"sensors[?id == `{x}`]|[0]|state",
                     },
                 ]
             ],
@@ -530,7 +532,7 @@ BOX_TYPE_CONF: dict[str, dict[int, dict[str, Any]]] = {
                     {
                         "temperature": "tempSensor.sensors[?id == `0`]|[0]|value",
                         "trend": "tempSensor.sensors[?id == `0`]|[0]|trend",
-                        "state": "tempSensor.sensors[?id == `0`]|[0]|state",
+                        "temperature.state": "tempSensor.sensors[?id == `0`]|[0]|state",
                         "elapsed": "tempSensor.sensors[?id == `0`]|[0]|elapsedTimeS",
                     },
                 ]
@@ -682,7 +684,9 @@ BOX_TYPE_CONF: dict[str, dict[int, dict[str, Any]]] = {
                     "multiSensor",
                     {
                         "temperature": lambda x: f"multiSensor.sensors[?id == `{x}`]|[0]|value",
+                        "temperature.state": lambda x: f"multiSensor.sensors[?id == `{x}`]|[0]|state",
                         "wind": lambda x: f"multiSensor.sensors[?id == `{x}`]|[0]|value",
+                        "wind.state": lambda x: f"multiSensor.sensors[?id == `{x}`]|[0]|state",
                     },
                 ]
             ],
@@ -704,8 +708,11 @@ BOX_TYPE_CONF: dict[str, dict[int, dict[str, Any]]] = {
                     "multiSensor",
                     {
                         "temperature": lambda x: f"multiSensor.sensors[?id == `{x}`]|[0]|value",
+                        "temperature.state": lambda x: f"multiSensor.sensors[?id == `{x}`]|[0]|state",
                         "wind": lambda x: f"multiSensor.sensors[?id == `{x}`]|[0]|value",
+                        "wind.state": lambda x: f"multiSensor.sensors[?id == `{x}`]|[0]|state",
                         "humidity": lambda x: f"multiSensor.sensors[?id == `{x}`]|[0]|value",
+                        "humidity.state": lambda x: f"multiSensor.sensors[?id == `{x}`]|[0]|state",
                     },
                 ]
             ],
@@ -727,9 +734,13 @@ BOX_TYPE_CONF: dict[str, dict[int, dict[str, Any]]] = {
                     "multiSensor",
                     {
                         "illuminance": lambda x: f"multiSensor.sensors[?id == `{x}`]|[0]|value",
+                        "illuminance.state": lambda x: f"multiSensor.sensors[?id == `{x}`]|[0]|state",
                         "temperature": lambda x: f"multiSensor.sensors[?id == `{x}`]|[0]|value",
+                        "temperature.state": lambda x: f"multiSensor.sensors[?id == `{x}`]|[0]|state",
                         "wind": lambda x: f"multiSensor.sensors[?id == `{x}`]|[?type == 'wind']|[0]|value",
+                        "wind.state": lambda x: f"multiSensor.sensors[?id == `{x}`]|[?type == 'wind']|[0]|state",
                         "humidity": lambda x: f"multiSensor.sensors[?id == `{x}`]|[0]|value",
+                        "humidity.state": lambda x: f"multiSensor.sensors[?id == `{x}`]|[0]|state",
                     },
                 ]
             ],
@@ -751,22 +762,47 @@ BOX_TYPE_CONF: dict[str, dict[int, dict[str, Any]]] = {
                     "multiSensor",
                     {
                         "frequency": lambda x: f"multiSensor.sensors[?id == `{x}`]|[?type == 'frequency']|[0]|value",
+                        "frequency.state": lambda x: f"multiSensor.sensors[?id == `{x}`]|[?type == 'frequency']|[0]|state",
                         "current": lambda x: f"multiSensor.sensors[?id == `{x}`]|[?type == 'current']|[0]|value",
+                        "current.state": lambda x: f"multiSensor.sensors[?id == `{x}`]|[?type == 'current']|[0]|state",
                         "voltage": lambda x: f"multiSensor.sensors[?id == `{x}`]|[?type == 'voltage']|[0]|value",
+                        "voltage.state": lambda x: f"multiSensor.sensors[?id == `{x}`]|[?type == 'voltage']|[0]|state",
                         "apparentPower": lambda x: f"multiSensor.sensors[?id == `{x}`]|[?type == 'apparentPower']|[0]|value",
+                        "apparentPower.state": lambda x: f"multiSensor.sensors[?id == `{x}`]|[?type == 'apparentPower']|[0]|state",
                         "activePower": lambda x: f"multiSensor.sensors[?id == `{x}`]|[?type == 'activePower']|[0]|value",
+                        "activePower.state": lambda x: f"multiSensor.sensors[?id == `{x}`]|[?type == 'activePower']|[0]|state",
                         "reactivePower": lambda x: f"multiSensor.sensors[?id == `{x}`]|[?type == 'reactivePower']|[0]|value",
+                        "reactivePower.state": lambda x: f"multiSensor.sensors[?id == `{x}`]|[?type == 'reactivePower']|[0]|state",
                         "reverseActiveEnergy": lambda x: f"multiSensor.sensors[?id == `{x}`]|[?type == 'reverseActiveEnergy']|[0]|value",
+                        "reverseActiveEnergy.state": lambda x: f"multiSensor.sensors[?id == `{x}`]|[?type == 'reverseActiveEnergy']|[0]|state",
                         "forwardActiveEnergy": lambda x: f"multiSensor.sensors[?id == `{x}`]|[?type == 'forwardActiveEnergy']|[0]|value",
+                        "forwardActiveEnergy.state": lambda x: f"multiSensor.sensors[?id == `{x}`]|[?type == 'forwardActiveEnergy']|[0]|state",
                         "forwardReactiveEnergy": lambda x: f"multiSensor.sensors[?id == `{x}`]|[?type == 'forwardReactiveEnergy']|[0]|value",
+                        "forwardReactiveEnergy.state": lambda x: f"multiSensor.sensors[?id == `{x}`]|[?type == 'forwardReactiveEnergy']|[0]|state",
                         "reverseReactiveEnergy": lambda x: f"multiSensor.sensors[?id == `{x}`]|[?type == 'reverseReactiveEnergy']|[0]|value",
+                        "reverseReactiveEnergy.state": lambda x: f"multiSensor.sensors[?id == `{x}`]|[?type == 'reverseReactiveEnergy']|[0]|state",
                         "illuminance": lambda x: f"multiSensor.sensors[?id == `{x}`]|[?type == 'illuminance']|[0]|value",
+                        "illuminance.state": lambda x: f"multiSensor.sensors[?id == `{x}`]|[?type == 'illuminance']|[0]|state",
                         "temperature": lambda x: f"multiSensor.sensors[?id == `{x}`]|[?type == 'temperature']|[0]|value",
+                        "temperature.state": lambda x: f"multiSensor.sensors[?id == `{x}`]|[?type == 'temperature']|[0]|state",
                         "wind": lambda x: f"multiSensor.sensors[?id == `{x}`]|[?type == 'wind']|[0]|value",
+                        "wind.state": lambda x: f"multiSensor.sensors[?id == `{x}`]|[?type == 'wind']|[0]|state",
                         "humidity": lambda x: f"multiSensor.sensors[?id == `{x}`]|[?type == 'humidity']|[0]|value",
+                        "humidity.state": lambda x: f"multiSensor.sensors[?id == `{x}`]|[?type == 'humidity']|[0]|state",
                         "openStatus": lambda x: f"multiSensor.sensors[?id == `{x}`]|[?type == 'openStatus']|[0]|value",
+                        "openStatus.state": lambda x: f"multiSensor.sensors[?id == `{x}`]|[?type == 'openStatus']|[0]|state",
                         "co2": lambda x: f"multiSensor.sensors[?id == `{x}`]|[?type == 'co2']|[0]|value",
+                        "co2.state": lambda x: f"multiSensor.sensors[?id == `{x}`]|[?type == 'co2']|[0]|state",
                         "co2Definition": lambda x: f"multiSensor.sensors[?id == `{x}`]|[?type == 'co2Definition']|[0]|value",
+                        "co2Definition.state": lambda x: f"multiSensor.sensors[?id == `{x}`]|[?type == 'co2Definition']|[0]|state",
+                        "gaugePressure": lambda x: f"multiSensor.sensors[?id == `{x}`]|[?type == 'gaugePressure']|[0]|value",
+                        "gaugePressure.state": lambda x: f"multiSensor.sensors[?id == `{x}`]|[?type == 'gaugePressure']|[0]|state",
+                        "liquidHeight": lambda x: f"multiSensor.sensors[?id == `{x}`]|[?type == 'liquidHeight']|[0]|value",
+                        "liquidHeight.state": lambda x: f"multiSensor.sensors[?id == `{x}`]|[?type == 'liquidHeight']|[0]|state",
+                        "fillLevel": lambda x: f"multiSensor.sensors[?id == `{x}`]|[?type == 'fillLevel']|[0]|value",
+                        "fillLevel.state": lambda x: f"multiSensor.sensors[?id == `{x}`]|[?type == 'fillLevel']|[0]|state",
+                        "volume": lambda x: f"multiSensor.sensors[?id == `{x}`]|[?type == 'volume']|[0]|value",
+                        "volume.state": lambda x: f"multiSensor.sensors[?id == `{x}`]|[?type == 'volume']|[0]|state",
                     },
                 ]
             ],

{blebox_uniapi-2.5.6 → blebox_uniapi-2.5.8}/blebox_uniapi/climate.py

@@ -1,9 +1,19 @@
+from enum import IntEnum
 from .sensor import Temperature
 from typing import Optional, Any, Union
 from .feature import Feature
 from blebox_uniapi.jfollow import follow
 
 
+class BleboxThermoState(IntEnum):
+    """Possible states of a thermo regulator, as reported by the device."""
+
+    OFF = 0
+    ON = 1
+    BOOST = 3
+    SAFETY_OFF = 4
+
+
 class Climate(Temperature):
     _is_on: Optional[bool]
     _desired: Union[float, int, None]
@@ -90,12 +100,18 @@ class Climate(Temperature):
             raw = self.raw_value("state")
             if raw is not None:  # no reading
                 alias = self._alias
-                return product.expect_int(alias, raw, 3, 0) in (
-                    1,
-                    3,
-                )  # 1: On, 3: Boost(thermoBox max temp of mode)
+                return product.expect_int(alias, raw, max(BleboxThermoState), 0) in (
+                    BleboxThermoState.ON,
+                    BleboxThermoState.BOOST,
+                )
         return None
 
+    def _read_safety_off(self) -> bool:
+        """Return True when the safety system forced the output off."""
+        if self._product.last_data is None:
+            return False
+        return self.raw_value("state") == BleboxThermoState.SAFETY_OFF
+
     def _read_operating_state(self) -> Optional[int]:
         """Return current operating state"""
         if self._product.last_data is not None:
@@ -107,13 +123,13 @@ class Climate(Temperature):
                 return None
 
     def _read_is_heating(self) -> Optional[bool]:
-        if not self._product.last_data:
+        if not self._product.last_data or self.current is None or self.desired is None:
             return None
 
         return self.is_on and (self.current < self.desired)
 
     def _read_is_cooling(self) -> Optional[bool]:
-        if not self._product.last_data:
+        if not self._product.last_data or self.current is None or self.desired is None:
             return None
 
         return self.is_on and (self.current > self.desired)
@@ -131,7 +147,22 @@ class Climate(Temperature):
     def after_update(self) -> None:
         self._is_on = self._read_is_on()
         self._desired = self._read_temperature("desired")
-        self._current = self._read_temperature("temperature")
+
+        state = self._read_state("temperature")
+        if self._state_is_error(state):
+            self._error = True
+            self._current = None
+        else:
+            self._error = False
+            if self._state_is_initializing(state):
+                self._current = None
+            else:
+                self._current = self._read_temperature("temperature")
+
+        if self._read_safety_off():
+            self._error = True
+
+        self._native_value = self._current
         self._is_heating = self._read_is_heating()
         self._is_cooling = self._read_is_cooling()
         self._havc_action = self._read_operating_state()

{blebox_uniapi-2.5.6 → blebox_uniapi-2.5.8}/blebox_uniapi/sensor.py

@@ -1,5 +1,5 @@
 import datetime
-import numbers
+from enum import IntEnum
 from functools import partial
 
 from .feature import Feature
@@ -67,10 +67,9 @@ class SensorFactory:
                     # note: methods for sensor readings are provided as template
                     # functions (lambdas) in the box config. We need to "materialize"
                     # them to make sure they are properly indexed by sensor ID
-                    materialized_methods = {
-                        **methods,
-                        device_class: methods[device_class](sensor_id),
-                    }
+                    materialized_methods = Feature.resolve_access_method_paths(
+                        methods, sensor_id
+                    )
 
                     feature = constructor(
                         product=product,
@@ -97,12 +96,26 @@ class SensorFactory:
             return []
 
 
+class BleboxSensorState(IntEnum):
+    """Possible states of a sensor reading, not all valid for every device type."""
+
+    IDLE = 0
+    INITIALIZING = 1
+    ACTIVE = 2
+    ERROR = 3
+    ABOVE_RANGE = 4
+    BELOW_RANGE = 5
+    NOT_CONFIGURED = 6
+
+
 class BaseSensor(Feature):
     _unit: str
     _device_class: str
-    _native_value: Union[float, int, str]
+    _native_value: Optional[Union[float, int, str]] = None
     _sensor_type: Optional[str]
     _sensor_id: Optional[int]
+    _error: bool = False
+    _needs_configuration: bool = False
 
     def __init__(
         self,
@@ -130,6 +143,31 @@ class BaseSensor(Feature):
     def native_value(self):
         return self._native_value
 
+    @property
+    def is_error(self) -> bool:
+        return self._error
+
+    @property
+    def needs_configuration(self) -> bool:
+        return self._needs_configuration
+
+    def _read_state(self, name: str) -> Optional[int]:
+        if self._product.last_data is None:
+            return None
+        raw = self.raw_value(f"{name}.state")
+        state = int(raw) if isinstance(raw, (int, float)) else None
+        self._needs_configuration = state == BleboxSensorState.NOT_CONFIGURED
+        return state
+
+    @staticmethod
+    def _state_is_error(state: Optional[int]) -> bool:
+        # note: unconfigured probe reports garbage values
+        return state in (BleboxSensorState.ERROR, BleboxSensorState.NOT_CONFIGURED)
+
+    @staticmethod
+    def _state_is_initializing(state: Optional[int]) -> bool:
+        return state == BleboxSensorState.INITIALIZING
+
     @property
     def sensor_id(self):
         return self._sensor_id
@@ -170,6 +208,10 @@ class BaseSensor(Feature):
 @SensorFactory.register("openStatus", unit="")
 @SensorFactory.register("co2", unit="ppm")
 @SensorFactory.register("co2Definition", unit="")
+@SensorFactory.register("gaugePressure", unit="mbar")
+@SensorFactory.register("liquidHeight", unit="cm")
+@SensorFactory.register("fillLevel", unit="percentage", scale=10)
+@SensorFactory.register("volume", unit="L")
 class GenericSensor(BaseSensor):
     def __init__(
         # base sensor params
@@ -201,9 +243,22 @@ class GenericSensor(BaseSensor):
         if product.last_data is None:
             return
 
+        state = self._read_state(self._device_class)
+        if self._state_is_error(state):
+            self._error = True
+            self._native_value = None
+            return
+
+        self._error = False
+
+        if self._state_is_initializing(state):
+            self._native_value = None
+            return
+
         raw = self.raw_value(self._device_class)
-        if not isinstance(raw, numbers.Number):
-            raw = float("nan")
+        if not isinstance(raw, (int, float)):
+            self._native_value = None
+            return
 
         native = raw / self._scale
         if self._precision:
@@ -234,7 +289,7 @@ class PowerConsumption(GenericSensor):
 
 @SensorFactory.register("temperature")
 class Temperature(BaseSensor):
-    _current: Union[float, int, None]
+    _current: Optional[Union[float, int]]
 
     def __init__(
         self,
@@ -249,21 +304,35 @@ class Temperature(BaseSensor):
         self._device_class = "temperature"
 
     @property
-    def current(self) -> Union[float, int, None]:
+    def current(self) -> Optional[Union[float, int]]:
         return self._current
 
-    def _read_temperature(self, field: str) -> Union[float, int, None]:
+    def _read_temperature(self, field: str) -> Optional[Union[float, int]]:
         product = self._product
         if product.last_data is not None:
             raw = self.raw_value(field)
-            if raw is not None:
-                alias = self._alias
-                return round(product.expect_int(alias, raw, 12500, -5500) / 100.0, 1)
+            if isinstance(raw, (int, float)):
+                return round(raw / 100.0, 1)
         return None
 
     def after_update(self) -> None:
-        self._current = self._read_temperature("temperature")
-        self._native_value = self._read_temperature("temperature")
+        state = self._read_state("temperature")
+        if self._state_is_error(state):
+            self._error = True
+            self._current = None
+            self._native_value = None
+            return
+
+        self._error = False
+
+        if self._state_is_initializing(state):
+            self._current = None
+            self._native_value = None
+            return
+
+        current = self._read_temperature("temperature")
+        self._current = current
+        self._native_value = current
 
 
 @SensorFactory.register("airSensor")
@@ -282,14 +351,25 @@ class AirQuality(BaseSensor):
         self._unit = "concentration_of_mp"
         self._device_class = alias
 
-    def _pm_value(self, name: str) -> Optional[int]:
+    def _pm_value(self, name: str) -> Optional[Union[int, float]]:
         product = self._product
         if product.last_data is not None:
             raw = self.raw_value(name)
-            if raw is not None:
-                alias = self._alias
-                return product.expect_int(alias, raw, 3000, 0)
+            if isinstance(raw, (int, float)):
+                return raw
         return None
 
     def after_update(self) -> None:
+        state = self._read_state(self.device_class)
+        if self._state_is_error(state):
+            self._error = True
+            self._native_value = None
+            return
+
+        self._error = False
+
+        if self._state_is_initializing(state):
+            self._native_value = None
+            return
+
         self._native_value = self._pm_value(f"{self.device_class}.value")

{blebox_uniapi-2.5.6 → blebox_uniapi-2.5.8}/blebox_uniapi.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: blebox_uniapi
-Version: 2.5.6
+Version: 2.5.8
 Summary: Python API for accessing BleBox smart home devices
 Home-page: https://github.com/blebox/blebox_uniapi
 Author: BleBox

{blebox_uniapi-2.5.6 → blebox_uniapi-2.5.8}/setup.cfg

@@ -1,5 +1,5 @@
 [bumpversion]
-current_version = 2.5.6
+current_version = 2.5.8
 commit = True
 tag = True
 tag_name = v{new_version}

{blebox_uniapi-2.5.6 → blebox_uniapi-2.5.8}/setup.py

@@ -23,7 +23,7 @@ test_requirements = [
 ]
 
 setup(
-    version="2.5.6",
+    version="2.5.8",
     author="BleBox",
     author_email="opensource@blebox.eu",
     python_requires=">=3.9",

{blebox_uniapi-2.5.6 → blebox_uniapi-2.5.8}/tests/test_box.py

@@ -234,3 +234,21 @@ async def test_async_ota_check_returns_silently_when_no_available_fv(
     with patch("asyncio.sleep", new=AsyncMock()):
         await box.async_ota_check()
     assert box.available_firmware_version is None
+
+
+async def test_async_ota_check_falls_back_to_info(mock_session, sample_data, config):
+    box = Box(mock_session, sample_data, config, None)
+    mock_session.async_api_get_ota = AsyncMock(return_value=None)
+    mock_session.async_api_get = AsyncMock(
+        side_effect=[
+            error.HttpError("Request to /api/device/state failed with HTTP 404"),
+            {"device": {"availableFv": "2.0", "fv": "1.5"}},
+        ]
+    )
+    with patch("asyncio.sleep", new=AsyncMock()):
+        await box.async_ota_check()
+    mock_session.async_api_get.assert_has_calls(
+        [mock.call("/api/device/state"), mock.call("/info")]
+    )
+    assert box.available_firmware_version == "2.0"
+    assert box.firmware_version == "1.5"

{blebox_uniapi-2.5.6 → blebox_uniapi-2.5.8}/tests/test_climate.py

@@ -39,7 +39,6 @@ class BleBoxClimateEntity(CommonEntity, ClimateDevice):
     def __init__(self, feature):
         super().__init__(feature)
         ClimateDevice.__init__(self)
-        pass
 
     """Representation of a BleBox climate feature."""
 
@@ -294,6 +293,45 @@ class TestSauna(DefaultBoxTest):
         entity = (await self.async_entities(aioclient_mock))[0]
         assert entity.device_info["name"] == "My ThermoBox"
 
+    async def test_thermo_sensor_error_state(self, aioclient_mock):
+        """A broken probe (state=3, out-of-range value) must not prevent setup."""
+        self.DEVICE_INFO = self.DEVICE_INFO_THERMO
+        self.DEVICE_EXTENDED_INFO = jmerge(
+            self.DEVICE_EXTENDED_INFO_THERMO,
+            '{ "sensors": [ { "value": 18349, "state": 3 } ] }',
+        )
+        await self.allow_get_info(aioclient_mock)
+        entity = (await self.async_entities(aioclient_mock))[0]
+
+        assert entity.current_temperature is None
+        assert entity._feature.is_error is True
+
+    async def test_thermo_sensor_initializing_state(self, aioclient_mock):
+        """state=1 (measurement in progress) must not surface a value or an error."""
+        self.DEVICE_INFO = self.DEVICE_INFO_THERMO
+        self.DEVICE_EXTENDED_INFO = jmerge(
+            self.DEVICE_EXTENDED_INFO_THERMO,
+            '{ "sensors": [ { "value": 18349, "state": 1 } ] }',
+        )
+        await self.allow_get_info(aioclient_mock)
+        entity = (await self.async_entities(aioclient_mock))[0]
+
+        assert entity.current_temperature is None
+        assert entity._feature.is_error is False
+
+    async def test_thermo_safety_off_state(self, aioclient_mock):
+        """state=4 (output blocked by safety system) must not prevent setup."""
+        self.DEVICE_INFO = self.DEVICE_INFO_THERMO
+        self.DEVICE_EXTENDED_INFO = jmerge(
+            self.DEVICE_EXTENDED_INFO_THERMO,
+            '{ "thermo": { "state": 4 } }',
+        )
+        await self.allow_get_info(aioclient_mock)
+        entity = (await self.async_entities(aioclient_mock))[0]
+
+        assert entity._feature.is_on is False
+        assert entity._feature.is_error is True
+
     async def test_device_info(self, aioclient_mock):
         await self.allow_get_info(aioclient_mock, self.DEVICE_INFO)
         entity = (await self.async_entities(aioclient_mock))[0]

{blebox_uniapi-2.5.6 → blebox_uniapi-2.5.8}/tests/test_sensor.py

@@ -283,6 +283,73 @@ class TestTempSensor(DefaultBoxTest):
 
         assert entity.native_value == 1.2
 
+    STATE_SENSOR_ERROR = json.loads(
+        """
+    {
+      "tempSensor": {
+        "sensors": [
+          {
+            "type": "temperature",
+            "id": 0,
+            "value": 18349,
+            "trend": 3,
+            "state": 3,
+            "elapsedTimeS": 0
+          }
+        ]
+      }
+    }
+    """
+    )
+
+    async def test_update_with_sensor_error_state_ignores_out_of_range_value(
+        self, aioclient_mock
+    ):
+        """Regression test: a broken probe must not prevent device setup."""
+
+        entity = await self.updated(aioclient_mock, self.STATE_SENSOR_ERROR)
+
+        assert entity.native_value is None
+        assert entity._feature.is_error is True
+
+    async def test_valid_state_trusts_out_of_nominal_range_value(self, aioclient_mock):
+        """state == 2 means the value is valid, even outside the nominal range."""
+
+        state = jmerge(
+            self.STATE_DEFAULT,
+            '{ "tempSensor": { "sensors": [ { "value": 18349, "state": 2 } ] } }',
+        )
+
+        entity = await self.updated(aioclient_mock, state)
+
+        assert entity._feature.is_error is False
+        assert entity.native_value == 183.5
+
+    async def test_initializing_state_reports_unknown_not_error(self, aioclient_mock):
+        """state == 1 (measurement in progress) must not surface a value or an error."""
+
+        state = jmerge(
+            self.STATE_DEFAULT,
+            '{ "tempSensor": { "sensors": [ { "value": 18349, "state": 1 } ] } }',
+        )
+
+        entity = await self.updated(aioclient_mock, state)
+
+        assert entity._feature.is_error is False
+        assert entity.native_value is None
+
+    async def test_update_recovers_after_sensor_error_clears(self, aioclient_mock):
+        """Entity value is restored once the sensor reports a valid state again."""
+
+        entity = await self.updated(aioclient_mock, self.STATE_SENSOR_ERROR)
+        assert entity._feature.is_error is True
+
+        product = entity._feature.product
+        product._update_last_data(self.STATE_DEFAULT)
+
+        assert entity._feature.is_error is False
+        assert entity.native_value == 25.2
+
 
 class TestMultiSensorEnergy(DefaultBoxTest):
     """Tests for multiSensor energy/current sensors (apiLevel 20230606)."""
@@ -351,6 +418,146 @@ class TestMultiSensorEnergy(DefaultBoxTest):
         assert entity._feature.unit == unit
         assert entity.native_value == value
 
+    async def test_sensor_error_state_reports_error(self, aioclient_mock):
+        """state == 3 is the only value that marks the sensor as errored."""
+
+        state_json = jmerge(
+            self.STATE_DEFAULT,
+            '{ "multiSensor": { "sensors": [ { "state": 3 } ] } }',
+        )
+
+        entity = await self.updated(aioclient_mock, state_json, index=0)
+
+        assert entity.native_value is None
+        assert entity._feature.is_error is True
+
+    async def test_sensor_initializing_state_reports_unknown_not_error(
+        self, aioclient_mock
+    ):
+        """state == 1 (measurement in progress) must not surface a value or an error."""
+
+        state_json = jmerge(
+            self.STATE_DEFAULT,
+            '{ "multiSensor": { "sensors": [ { "state": 1 } ] } }',
+        )
+
+        entity = await self.updated(aioclient_mock, state_json, index=0)
+
+        assert entity._feature.is_error is False
+        assert entity.native_value is None
+
+    @pytest.mark.parametrize("state", [0, 2, 4, 5])
+    async def test_sensor_valid_state_reports_value(self, aioclient_mock, state):
+        """States other than 1 (init) and 3 (error) trust the reported value,
+        including 4/5 (out of range), where value is the measurement limit."""
+
+        state_json = jmerge(
+            self.STATE_DEFAULT,
+            f'{{ "multiSensor": {{ "sensors": [ {{ "state": {state} }} ] }} }}',
+        )
+
+        entity = await self.updated(aioclient_mock, state_json, index=0)
+
+        assert entity._feature.is_error is False
+        assert entity.native_value == 1500
+
+
+class TestMultiSensorTank(DefaultBoxTest):
+    """Tests for multiSensor tank level sensors (apiLevel 20230606)."""
+
+    DEVCLASS = "sensors"
+    ENTITY_CLASS = BleBoxSensorEntity
+
+    DEV_INFO_PATH = "state"
+
+    DEVICE_INFO = json.loads(
+        """
+        {
+          "device": {
+            "deviceName": "My tankSensor",
+            "type": "multiSensor",
+            "product": "tankSensor",
+            "hv": "tS-1.0",
+            "fv": "0.1",
+            "universe": 0,
+            "apiLevel": "20230606",
+            "id": "aa00112233bb",
+            "ip": "172.0.0.1",
+            "availableFv": null
+          }
+        }
+        """
+    )
+
+    def patch_version(apiLevel):
+        return f'{{ "device": {{ "apiLevel": {apiLevel} }} }}'
+
+    DEVICE_INFO_FUTURE = jmerge(DEVICE_INFO, patch_version(future_date()))
+    DEVICE_INFO_LATEST = jmerge(
+        DEVICE_INFO, patch_version(get_latest_api_level("multiSensor"))
+    )
+    DEVICE_INFO_UNSUPPORTED = jmerge(DEVICE_INFO, patch_version(20180603))
+    DEVICE_INFO_UNSPECIFIED_API = None
+
+    STATE_DEFAULT = json.loads(
+        """
+        {
+            "multiSensor": {
+                "sensors": [
+                    {"type": "gaugePressure", "id": 0, "value": 98,   "state": 2},
+                    {"type": "liquidHeight",  "id": 1, "value": 100,  "state": 2},
+                    {"type": "fillLevel",     "id": 2, "value": 205,  "state": 2},
+                    {"type": "volume",        "id": 3, "value": 2000, "state": 2}
+                ]
+            }
+        }
+        """
+    )
+
+    DEVICE_EXTENDED_INFO = STATE_DEFAULT
+    DEVICE_EXTENDED_INFO_PATH = "/state/extended"
+
+    @pytest.mark.parametrize(
+        "index,unit,value",
+        [
+            (0, "mbar", 98),
+            (1, "cm", 100),
+            (2, "percentage", 20.5),
+            (3, "L", 2000),
+        ],
+    )
+    async def test_sensor_value(self, aioclient_mock, index, unit, value):
+        entity = await self.updated(aioclient_mock, self.STATE_DEFAULT, index=index)
+        assert entity._feature.unit == unit
+        assert entity.native_value == value
+        assert entity._feature.needs_configuration is False
+
+    @pytest.mark.parametrize("value", [None, 9999])
+    async def test_not_configured_state_reports_error(self, aioclient_mock, value):
+        """state == 6 (probe not configured) carries a meaningless or null value."""
+
+        state_json = jmerge(
+            self.STATE_DEFAULT,
+            json.dumps({"multiSensor": {"sensors": [{"state": 6, "value": value}]}}),
+        )
+
+        entity = await self.updated(aioclient_mock, state_json, index=0)
+
+        assert entity.native_value is None
+        assert entity._feature.is_error is True
+        assert entity._feature.needs_configuration is True
+
+    async def test_error_state_does_not_need_configuration(self, aioclient_mock):
+        state_json = jmerge(
+            self.STATE_DEFAULT,
+            '{ "multiSensor": { "sensors": [ { "state": 3 } ] } }',
+        )
+
+        entity = await self.updated(aioclient_mock, state_json, index=0)
+
+        assert entity._feature.is_error is True
+        assert entity._feature.needs_configuration is False
+
 
 class TestAirSensor(DefaultBoxTest):
     """Tests for sensors representing BleBox airSensor."""