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

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: blebox_uniapi
-Version: 2.5.7
+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.7 → blebox_uniapi-2.5.8}/blebox_uniapi/__init__.py

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

{blebox_uniapi-2.5.7 → 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.7 → blebox_uniapi-2.5.8}/blebox_uniapi/box_types.py

@@ -795,6 +795,14 @@ BOX_TYPE_CONF: dict[str, dict[int, dict[str, Any]]] = {
                         "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.7 → blebox_uniapi-2.5.8}/blebox_uniapi/sensor.py

@@ -105,6 +105,7 @@ class BleboxSensorState(IntEnum):
     ERROR = 3
     ABOVE_RANGE = 4
     BELOW_RANGE = 5
+    NOT_CONFIGURED = 6
 
 
 class BaseSensor(Feature):
@@ -114,6 +115,7 @@ class BaseSensor(Feature):
     _sensor_type: Optional[str]
     _sensor_id: Optional[int]
     _error: bool = False
+    _needs_configuration: bool = False
 
     def __init__(
         self,
@@ -145,17 +147,22 @@ class BaseSensor(Feature):
     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")
-        if not isinstance(raw, (int, float)):
-            return None
-        return int(raw)
+        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:
-        return state == BleboxSensorState.ERROR
+        # note: unconfigured probe reports garbage values
+        return state in (BleboxSensorState.ERROR, BleboxSensorState.NOT_CONFIGURED)
 
     @staticmethod
     def _state_is_initializing(state: Optional[int]) -> bool:
@@ -201,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

{blebox_uniapi-2.5.7 → 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.7
+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.7 → blebox_uniapi-2.5.8}/setup.cfg

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

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

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

{blebox_uniapi-2.5.7 → 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.7 → blebox_uniapi-2.5.8}/tests/test_sensor.py

@@ -462,6 +462,103 @@ class TestMultiSensorEnergy(DefaultBoxTest):
         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."""