blebox-uniapi 2.5.2__tar.gz → 2.5.4__tar.gz

{blebox_uniapi-2.5.2 → blebox_uniapi-2.5.4}/PKG-INFO

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

{blebox_uniapi-2.5.2 → blebox_uniapi-2.5.4}/blebox_uniapi/__init__.py

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

blebox_uniapi-2.5.4/blebox_uniapi/binary_sensor.py

@@ -0,0 +1,189 @@
+from typing import Union, Optional, TYPE_CHECKING
+
+from .feature import Feature
+
+if TYPE_CHECKING:
+    from .box import Box
+
+
+class BinarySensor(Feature):
+    """Class representing sensor with bool state."""
+
+    def __init__(
+        self,
+        product: "Box",
+        alias: str,
+        methods: dict,
+        sensor_id: Optional[int] = None,
+        name: Optional[str] = None,
+    ):
+        self._sensor_id = sensor_id
+        self._name = name
+        super().__init__(product, alias, methods)
+
+    @property
+    def index(self) -> Optional[int]:
+        return self._sensor_id
+
+    @property
+    def name(self) -> Optional[str]:
+        return self._name
+
+    @classmethod
+    def many_from_config(
+        cls, product, box_type_config, extended_state
+    ) -> list["Feature"]:
+        type_class_map = {
+            "rain": Rain,
+            "flood": Flood,
+            "openStatus": Open,
+            "binary": Input,
+        }
+
+        output_list = list()
+        sensors_list = extended_state.get("multiSensor").get("sensors", {})
+        alias, methods = box_type_config[0]
+
+        for sensor in sensors_list:
+            sensor_type = sensor.get("type")
+            sensor_id = sensor.get("id")
+
+            if sensor_type in type_class_map:
+                klass = type_class_map[sensor_type]
+
+                if methods.get(sensor_type) is not None:
+                    value_method = {sensor_type: methods[sensor_type](sensor_id)}
+                    output_list.append(
+                        klass(
+                            product=product,
+                            alias=sensor_type + "_" + str(sensor_id),
+                            methods=value_method,
+                            sensor_id=sensor_id,
+                            name=sensor.get("name"),
+                        )
+                    )
+
+        return output_list
+
+
+class Rain(BinarySensor):
+    def __init__(
+        self,
+        product: "Box",
+        alias: str,
+        methods: dict,
+        sensor_id: Optional[int] = None,
+        name: Optional[str] = None,
+    ):
+        self._device_class = "moisture"
+        super().__init__(product, alias, methods, sensor_id=sensor_id, name=name)
+
+    @property
+    def state(self) -> bool:
+        return self._current > 0
+
+    @property
+    def device_class(self) -> str:
+        return self._device_class
+
+    def _read_rain(self, field: str) -> Union[float, int, None]:
+        product = self._product
+        if product.last_data is not None:
+            raw = self.raw_value(field)
+            if raw is not None:  # no reading
+                return self.raw_value("rain")
+        return 0
+
+    def after_update(self) -> None:
+        self._current = self._read_rain("rain")
+
+
+class Flood(BinarySensor):
+    def __init__(
+        self,
+        product: "Box",
+        alias: str,
+        methods: dict,
+        sensor_id: Optional[int] = None,
+        name: Optional[str] = None,
+    ):
+        self._device_class = "moisture"
+        super().__init__(product, alias, methods, sensor_id=sensor_id, name=name)
+
+    @property
+    def state(self) -> bool:
+        return self._current > 0
+
+    @property
+    def device_class(self) -> str:
+        return self._device_class
+
+    def _read_flood(self, field: str) -> Union[float, int, None]:
+        product = self._product
+
+        if product.last_data is not None:
+            raw = self.raw_value(field)
+            if raw is not None:  # no reading
+                return self.raw_value("flood")
+        return 0
+
+    def after_update(self) -> None:
+        self._current = self._read_flood("flood")
+
+
+class Open(BinarySensor):
+    def __init__(
+        self,
+        product: "Box",
+        alias: str,
+        methods: dict,
+        sensor_id: Optional[int] = None,
+        name: Optional[str] = None,
+    ):
+        self._device_class = "open"
+        super().__init__(product, alias, methods, sensor_id=sensor_id, name=name)
+
+    @property
+    def state(self) -> bool:
+        return self._current != 4  # 4 = closed, 0-3 = open
+
+    def _read_input(self, field: str) -> Union[float, int, None]:
+        product = self._product
+
+        if product.last_data is not None:
+            raw = self.raw_value(field)
+            if raw is not None:  # no reading
+                return self.raw_value("openStatus")
+        return 0
+
+    def after_update(self) -> None:
+        self._current = self._read_input("openStatus")
+
+
+class Input(BinarySensor):
+    def __init__(
+        self,
+        product: "Box",
+        alias: str,
+        methods: dict,
+        sensor_id: Optional[int] = None,
+        name: Optional[str] = None,
+    ):
+        self._device_class = "input"
+        super().__init__(product, alias, methods, sensor_id=sensor_id, name=name)
+
+    @property
+    def state(self) -> bool:
+        return self._current > 0
+
+    def _read_input(self, field: str) -> Union[float, int, None]:
+        product = self._product
+
+        if product.last_data is not None:
+            raw = self.raw_value(field)
+            if raw is not None:  # no reading
+                return self.raw_value("binary")
+        return 0
+
+    def after_update(self) -> None:
+        self._current = self._read_input("binary")

{blebox_uniapi-2.5.2 → blebox_uniapi-2.5.4}/blebox_uniapi/box.py

@@ -14,6 +14,7 @@ from .sensor import SensorFactory
 from .binary_sensor import BinarySensor
 from .session import ApiHost
 from .switch import Switch
+from .update import Update
 
 from .error import (
     UnsupportedBoxResponse,
@@ -27,7 +28,6 @@ from .error import (
     HttpError,
 )
 
-
 DEFAULT_PORT = 80
 
 
@@ -105,6 +105,8 @@ class Box:
                 info, f"{location} has no hardware version"
             ) from ex
 
+        available_firmware_version = info.get("availableFv")
+
         level = int(info.get("apiLevel", _DEFAULT_API_LEVEL))
 
         self._data_path = config["api_path"]
@@ -114,6 +116,7 @@ class Box:
         self._address = address
         self._firmware_version = firmware_version
         self._hardware_version = hardware_version
+        self._available_firmware_version = available_firmware_version
         self._api_version = level
         self._model = config.get("model", type)
         self._api = config.get("api", {})
@@ -143,6 +146,7 @@ class Box:
                     )
             except KeyError:
                 raise UnsupportedBoxResponse("Failed to initialize:", info)
+        features["updates"] = [Update(self, "update", {})]
         return features
 
     @classmethod
@@ -153,7 +157,9 @@ class Box:
         except HttpError:
             path = "/info"
             data = await api_host.async_api_get(path)
-        info = data.get("device", data)  # type: ignore
+        if data is None:
+            raise UnsupportedBoxResponse("Device returned non-JSON response")
+        info = data.get("device", data)
         extended_state = None
 
         config = cls._match_device_config(info)
@@ -218,6 +224,10 @@ class Box:
     def hardware_version(self) -> Any:
         return self._hardware_version
 
+    @property
+    def available_firmware_version(self) -> Any:
+        return self._available_firmware_version
+
     @property
     def api_version(self) -> int:
         return self._api_version
@@ -366,3 +376,19 @@ class Box:
                 response = await self._session.async_api_post(path, post_data)
             self._update_last_data(response)
             self._last_real_update = time.time()
+
+    async def async_ota_check(self) -> None:
+        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")
+            if response is None:
+                raise UnsupportedBoxResponse("Device returned non-JSON response")
+            response = response.get("device", response)
+            if response.get("availableFv") is not None:
+                self._firmware_version = response.get("fv", self._firmware_version)
+                self._available_firmware_version = response["availableFv"]
+                return
+
+    async def async_ota_update(self) -> None:
+        await self._session.async_api_get("/api/ota/update")

{blebox_uniapi-2.5.2 → blebox_uniapi-2.5.4}/blebox_uniapi/box_types.py

@@ -194,6 +194,14 @@ BOX_TYPE_CONF: dict[str, dict[int, dict[str, Any]]] = {
                     },
                 ]
             ],
+            "sensors": [
+                [
+                    "temperature",
+                    {
+                        "temperature": lambda x: f"sensors[?id == `{x}`]|[0]|value",
+                    },
+                ]
+            ],
         }
     },
     # saunaBox
@@ -720,6 +728,7 @@ BOX_TYPE_CONF: dict[str, dict[int, dict[str, Any]]] = {
                         "temperature": lambda x: f"multiSensor.sensors[?id == `{x}`]|[?type == 'temperature']|[0]|value",
                         "wind": lambda x: f"multiSensor.sensors[?id == `{x}`]|[?type == 'wind']|[0]|value",
                         "humidity": lambda x: f"multiSensor.sensors[?id == `{x}`]|[?type == 'humidity']|[0]|value",
+                        "openStatus": lambda x: f"multiSensor.sensors[?id == `{x}`]|[?type == 'openStatus']|[0]|value",
                     },
                 ]
             ],
@@ -729,6 +738,8 @@ BOX_TYPE_CONF: dict[str, dict[int, dict[str, Any]]] = {
                     {
                         "rain": lambda x: f"multiSensor.sensors[?id == `{x}`]|[?type == 'rain']|[0]|value",
                         "flood": lambda x: f"multiSensor.sensors[?id == `{x}`]|[?type == 'flood']|[0]|value",
+                        "openStatus": lambda x: f"multiSensor.sensors[?id == `{x}`]|[?type == 'openStatus']|[0]|value",
+                        "binary": lambda x: f"multiSensor.sensors[?id == `{x}`]|[?type == 'binary']|[0]|value",
                     },
                 ]
             ],

{blebox_uniapi-2.5.2 → blebox_uniapi-2.5.4}/blebox_uniapi/cover.py

@@ -33,12 +33,21 @@ class ShutterBoxControlType(IntEnum):
 
     SEGMENTED_SHUTTER = 1
     NO_CALIBRATION = 2
-    TILT_SHUTTER = 3
+    TILT_SHUTTER_90 = 3
     WINDOW_OPENER = 4
     MATERIAL_SHUTTER = 5
     AWNING = 6
     SCREEN = 7
     CURTAIN = 8
+    ROOF_SEGMENTED_SHUTTER = 9
+    SERVOMOTOR = 10
+    CURTAIN_ONE_SIDED = 11
+    CURTAIN_TWO_SIDED = 12
+    TILT_ONLY = 13
+    PERGOLA_ROOF = 14
+    PERGOLA_ROOF_TILT_ONLY = 15
+    TILT_SHUTTER_180 = 16
+    TILT_SHUTTER_WITHOUT_POSITIONING = 17
 
 
 class GateBoxControlType(IntEnum):
@@ -155,7 +164,34 @@ class Shutter(Gate):
 
     @property
     def has_tilt(self) -> bool:
-        return self._control_type == ShutterBoxControlType.TILT_SHUTTER
+        return self._control_type in (
+            ShutterBoxControlType.TILT_SHUTTER_90,
+            ShutterBoxControlType.TILT_SHUTTER_180,
+            ShutterBoxControlType.TILT_ONLY,
+            ShutterBoxControlType.PERGOLA_ROOF_TILT_ONLY,
+            ShutterBoxControlType.TILT_SHUTTER_WITHOUT_POSITIONING,
+        )
+
+    @property
+    def tilt_only(self) -> bool:
+        return self._control_type in (
+            ShutterBoxControlType.TILT_ONLY,
+            ShutterBoxControlType.PERGOLA_ROOF_TILT_ONLY,
+        )
+
+    @property
+    def is_tilt_180(self) -> bool:
+        return self._control_type == ShutterBoxControlType.TILT_SHUTTER_180
+
+    @property
+    def is_slider(self) -> bool:
+        return self._control_type not in (
+            ShutterBoxControlType.NO_CALIBRATION,
+            ShutterBoxControlType.CURTAIN,
+            ShutterBoxControlType.TILT_ONLY,
+            ShutterBoxControlType.PERGOLA_ROOF_TILT_ONLY,
+            ShutterBoxControlType.TILT_SHUTTER_WITHOUT_POSITIONING,
+        )
 
     def read_cover_type(
         self, alias: str, raw_value: Any, product: "Box"
@@ -164,7 +200,7 @@ class Shutter(Gate):
             return UnifiedCoverType.SHUTTER
         if self._control_type == ShutterBoxControlType.NO_CALIBRATION:
             return UnifiedCoverType.SHUTTER
-        if self._control_type == ShutterBoxControlType.TILT_SHUTTER:
+        if self._control_type == ShutterBoxControlType.TILT_SHUTTER_90:
             return UnifiedCoverType.SHUTTER
         if self._control_type == ShutterBoxControlType.WINDOW_OPENER:
             return UnifiedCoverType.WINDOW
@@ -176,6 +212,24 @@ class Shutter(Gate):
             return UnifiedCoverType.SHADE
         if self._control_type == ShutterBoxControlType.CURTAIN:
             return UnifiedCoverType.CURTAIN
+        if self._control_type == ShutterBoxControlType.ROOF_SEGMENTED_SHUTTER:
+            return UnifiedCoverType.SHUTTER
+        if self._control_type == ShutterBoxControlType.SERVOMOTOR:
+            return UnifiedCoverType.SHUTTER
+        if self._control_type == ShutterBoxControlType.CURTAIN_ONE_SIDED:
+            return UnifiedCoverType.CURTAIN
+        if self._control_type == ShutterBoxControlType.CURTAIN_TWO_SIDED:
+            return UnifiedCoverType.CURTAIN
+        if self._control_type == ShutterBoxControlType.TILT_ONLY:
+            return UnifiedCoverType.SHUTTER
+        if self._control_type == ShutterBoxControlType.PERGOLA_ROOF:
+            return UnifiedCoverType.AWNING
+        if self._control_type == ShutterBoxControlType.PERGOLA_ROOF_TILT_ONLY:
+            return UnifiedCoverType.AWNING
+        if self._control_type == ShutterBoxControlType.TILT_SHUTTER_180:
+            return UnifiedCoverType.SHUTTER
+        if self._control_type == ShutterBoxControlType.TILT_SHUTTER_WITHOUT_POSITIONING:
+            return UnifiedCoverType.SHUTTER
 
 
 class GateBox(Gate):
@@ -345,6 +399,22 @@ class Cover(Feature):
     def has_stop(self) -> bool:
         return self._has_stop
 
+    @property
+    def tilt_only(self) -> bool:
+        return (
+            self._attributes.tilt_only
+            if hasattr(self._attributes, "tilt_only")
+            else False
+        )
+
+    @property
+    def is_tilt_180(self) -> bool:
+        return (
+            self._attributes.is_tilt_180
+            if hasattr(self._attributes, "is_tilt_180")
+            else False
+        )
+
     @property
     def cover_type(self) -> Optional[UnifiedCoverType]:
         return self._cover_type

{blebox_uniapi-2.5.2 → blebox_uniapi-2.5.4}/blebox_uniapi/light.py

@@ -112,8 +112,10 @@ class Light(Feature):
         color_mode,
         effect_list,
         current_effect,
+        index: Optional[int] = None,
     ) -> None:
         super().__init__(product, alias, methods)
+        self._index = index
         config = self.CONFIG[product.type]
         self.mask = mask
         self.desired_color = desired_color
@@ -187,6 +189,7 @@ class Light(Feature):
                                 product,
                                 alias=alias + "_" + indicator,
                                 mask=mask,
+                                index=i,
                                 **const_kwargs,
                             )
                         )
@@ -208,12 +211,13 @@ class Light(Feature):
                 ct = ctx2
                 if len(desired_color) > 8:
                     ct = ctx2_v3
-                for indicator, mask in ct.items():
+                for i, (indicator, mask) in enumerate(ct.items()):
                     object_list.append(
                         cls(
                             product,
                             alias=alias + "_" + indicator,
                             mask=mask,
+                            index=i,
                             **const_kwargs,
                         )
                     )
@@ -247,6 +251,10 @@ class Light(Feature):
         else:
             return None
 
+    @property
+    def index(self) -> Optional[int]:
+        return self._index
+
     @property
     def effect_list(self):
         if isinstance(self._effect_list, dict):
@@ -272,6 +280,23 @@ class Light(Feature):
             )
         return int(max(iterable))
 
+    @staticmethod
+    def swap_ww_cw(value: list) -> list:
+        """Swap WW and CW channels in RGBWW mode for API compatibility."""
+        if len(value) == 5:
+            value = list(value)
+            value[3], value[4] = value[4], value[3]
+        return value
+
+    @staticmethod
+    def scale_rgbww_brightness(value: list, brightness: int) -> list:
+        """Scale RGBWW value preserving WW:CW ratio."""
+        current_max = max(value)
+        if current_max > 0:
+            return [round(x * brightness / current_max) for x in value]
+        else:
+            return [0, 0, 0, 0, brightness]
+
     def apply_brightness(self, value: int, brightness: int) -> Any:
         """Return list of values with applied brightness."""
         if not isinstance(brightness, int):
@@ -289,7 +314,17 @@ class Light(Feature):
         if brightness == 0:
             return [value]
 
-        res = list(map(lambda x: round(x * (brightness / 255)), value))
+        if self.color_mode in (
+            BleboxColorMode.RGB,
+            BleboxColorMode.RGBW,
+            BleboxColorMode.RGBorW,
+        ):
+            value = self.normalise_elements_of_rgb(list(value))
+            res = list(map(lambda x: round(x * (brightness / 255)), value))
+        elif self.color_mode == BleboxColorMode.RGBWW:
+            res = self.scale_rgbww_brightness(value, brightness)
+        else:
+            res = list(map(lambda x: round(x * (brightness / 255)), value))
         return res
 
     def evaluate_off_value(self, config: dict, raw_hex: str) -> str:
@@ -302,10 +337,10 @@ class Light(Feature):
         :return: str
         """
         if self.mask:
-            if len(raw_hex) < len(self.mask("x").replace("x", "")):
-                return "0" * len(raw_hex)
-            else:
-                return "0" * (len(raw_hex) - len(self.mask("x").replace("x", "")))
+            placeholder = self._get_placeholder_for_color_mode()
+            mask_result = self.mask(placeholder)
+            x_count = mask_result.count("x")
+            return "0" * x_count
         elif raw_hex is not None:
             if len(raw_hex) < len(config["off"]):
                 return config["off"][: len(raw_hex)]
@@ -348,6 +383,18 @@ class Light(Feature):
         white_hex = value[6:8]
         return f"{rgb_hex}{white_hex}"
 
+    def _get_placeholder_for_color_mode(self) -> str:
+        if self._color_mode == BleboxColorMode.MONO:
+            return "xx"
+        elif self._color_mode in (BleboxColorMode.CT, BleboxColorMode.CTx2):
+            return "xxxx"
+        elif self._color_mode == BleboxColorMode.RGB:
+            return "xxxxxx"
+        elif self._color_mode in (BleboxColorMode.RGBW, BleboxColorMode.RGBorW):
+            return "xxxxxxxx"
+        else:
+            return "x"
+
     def return_color_temp_with_brightness(
         self, value, brightness: Any
     ) -> Optional[str]:
@@ -366,17 +413,8 @@ class Light(Feature):
         return self.rgb_hex_to_rgb_list(warm + cold)
 
     def value_for_selected_channels_from_given_val(self, value: str):
-        if self.color_mode in [BleboxColorMode.CT, BleboxColorMode.CTx2]:
-            lambda_result = self.mask("xxxx")
-        elif self.color_mode == BleboxColorMode.MONO:
-            lambda_result = self.mask("xx")
-        elif self.color_mode == BleboxColorMode.RGB:
-            lambda_result = self.mask("xxxxxx")
-        elif (
-            self.color_mode == BleboxColorMode.RGBW
-            or self.color_mode == BleboxColorMode.RGBorW
-        ):
-            lambda_result = self.mask("xxxxxxxx")
+        placeholder = self._get_placeholder_for_color_mode()
+        lambda_result = self.mask(placeholder)
         first_index = lambda_result.index("x")
         last_index = lambda_result.rindex("x")
         return value[first_index : last_index + 1]
@@ -443,10 +481,9 @@ class Light(Feature):
 
     def _set_last_on_value(self, alias, product, raw):
         if raw == self._off_value:
-            if (
-                product.type == "wLightBox"
-            ):  # jezeli urzadzenie typu wLightBox ma wyciagnac last_color
-                raw = product.expect_rgbw(alias, self.raw_value("last_color"))
+            last_color = self.raw_value("last_color")
+            if last_color is not None:
+                raw = product.expect_rgbw(alias, last_color)
                 if self.mask is not None:
                     raw = self.value_for_selected_channels_from_given_val(raw)
                     if raw == self._off_value:
@@ -506,11 +543,15 @@ class Light(Feature):
                 if self.color_mode in (BleboxColorMode.RGBW, BleboxColorMode.RGBorW):
                     return 255, 255, 255, 255
                 if self.color_mode == BleboxColorMode.MONO:
-                    return 255
+                    return [255]
                 if self.color_mode in (BleboxColorMode.CT, BleboxColorMode.CTx2):
                     return 255, 255
             else:
-                if self.color_mode == BleboxColorMode.MONO:
+                if self.color_mode in (
+                    BleboxColorMode.MONO,
+                    BleboxColorMode.CT,
+                    BleboxColorMode.CTx2,
+                ):
                     return self.rgb_hex_to_rgb_list(self._last_on_state)
                 return self.normalise_elements_of_rgb(
                     self.rgb_hex_to_rgb_list(self._last_on_state)
@@ -521,11 +562,12 @@ class Light(Feature):
                     return [255] * len(self.rgb_hex_to_rgb_list(self._last_on_state))
                 else:
                     if self.color_mode == BleboxColorMode.RGB:
-                        return self.normalise_elements_of_rgb(
-                            self.rgb_hex_to_rgb_list(self._last_on_state[:6])
-                        )
+                        return self.rgb_hex_to_rgb_list(self._last_on_state[:6])
                     elif self.color_mode == BleboxColorMode.MONO:
                         return self._last_on_state
+                    elif self.color_mode == BleboxColorMode.RGBWW:
+                        result = self.rgb_hex_to_rgb_list(self._last_on_state)
+                        return self.swap_ww_cw(result)
                     else:
                         return self.rgb_hex_to_rgb_list(self._last_on_state)
             else:

{blebox_uniapi-2.5.2 → blebox_uniapi-2.5.4}/blebox_uniapi/sensor.py

@@ -77,6 +77,7 @@ class SensorFactory:
                         alias=alias,
                         methods=materialized_methods,
                         sensor_id=sensor_id,
+                        name=sensor.get("name"),
                     )
                     object_list.append(feature)
 
@@ -110,9 +111,11 @@ class BaseSensor(Feature):
         methods: dict,
         sensor_type: str = None,
         sensor_id: Optional[int] = None,
+        name: Optional[str] = None,
     ):
         self._sensor_type = sensor_type
         self._sensor_id = sensor_id
+        self._name = name
         super().__init__(product, alias, methods)
 
     @property
@@ -135,6 +138,14 @@ class BaseSensor(Feature):
     def probe_id(self):
         return self.sensor_id
 
+    @property
+    def index(self) -> Optional[int]:
+        return self._sensor_id
+
+    @property
+    def name(self) -> Optional[str]:
+        return self._name
+
     @classmethod
     def many_from_config(cls, product, box_type_config, extended_state):
         raise NotImplementedError("Please use SensorFactory")
@@ -154,6 +165,7 @@ class BaseSensor(Feature):
 @SensorFactory.register("illuminance", unit="lx", scale=100)
 @SensorFactory.register("humidity", unit="percentage", scale=100)
 @SensorFactory.register("wind", unit="m/s", scale=10)
+@SensorFactory.register("openStatus", unit="")
 class GenericSensor(BaseSensor):
     def __init__(
         # base sensor params
@@ -162,6 +174,7 @@ class GenericSensor(BaseSensor):
         alias: str,
         methods: dict,
         sensor_id: Optional[int],
+        name: Optional[str] = None,
         *,
         # generalization params
         sensor_type: str,
@@ -169,7 +182,7 @@ class GenericSensor(BaseSensor):
         scale: float = 1,
         precision: Optional[int] = None,
     ):
-        super().__init__(product, alias, methods, sensor_id=sensor_id)
+        super().__init__(product, alias, methods, sensor_id=sensor_id, name=name)
         self._unit = unit
         self._scale = scale
         self._precision = precision
@@ -225,8 +238,9 @@ class Temperature(BaseSensor):
         alias: str,
         methods: dict,
         sensor_id: Optional[int] = None,
+        name: Optional[str] = None,
     ):
-        super().__init__(product, alias, methods, sensor_id=sensor_id)
+        super().__init__(product, alias, methods, sensor_id=sensor_id, name=name)
         self._unit = "celsius"
         self._device_class = "temperature"
 
@@ -258,8 +272,9 @@ class AirQuality(BaseSensor):
         alias: str,
         methods: dict,
         sensor_id: Optional[str] = None,
+        name: Optional[str] = None,
     ):
-        super().__init__(product, alias, methods, sensor_id)
+        super().__init__(product, alias, methods, sensor_id, name=name)
         self._unit = "concentration_of_mp"
         self._device_class = alias
 

{blebox_uniapi-2.5.2 → blebox_uniapi-2.5.4}/blebox_uniapi/session.py

@@ -46,7 +46,11 @@ class ApiHost:
         self._loop = loop
 
     async def async_request(
-        self, path: str, async_method: Any, data: Union[dict, str, None] = None
+        self,
+        path: str,
+        async_method: Any,
+        data: Union[dict, str, None] = None,
+        allow_ota_check_response: bool = False,
     ) -> Optional[dict]:
         # TODO: check timeout
         client_timeout = self._timeout
@@ -57,7 +61,8 @@ class ApiHost:
             else:
                 response = await async_method(url, timeout=client_timeout)
 
-            if response.status != 200:
+            accepted_statuses = (200, 202, 204) if allow_ota_check_response else (200,)
+            if response.status not in accepted_statuses:
                 if response.status == 401:
                     raise error.UnauthorizedRequest(
                         f"Request to {url} failed with HTTP {response.status}, UNAUTHORISED"
@@ -66,6 +71,9 @@ class ApiHost:
                     f"Request to {url} failed with HTTP {response.status}"
                 )
 
+            if response.content_type != "application/json":
+                return None
+
             return await response.json()
 
         except asyncio.TimeoutError as ex:
@@ -81,6 +89,11 @@ class ApiHost:
         except aiohttp.ClientError as ex:
             raise error.ClientError(f"API request {url} failed: {ex}") from ex
 
+        except UnicodeDecodeError as ex:
+            raise error.ConnectionError(
+                f"Invalid response encoding from {url}: {ex}"
+            ) from ex
+
     async def async_api_get(self, path: str) -> Optional[dict]:
         try:
             return await self.async_request(path, self._session.get)
@@ -88,6 +101,15 @@ class ApiHost:
             logger.error(f"EXCEPTION DURING API CALL: {ex}")
             raise ex
 
+    async def async_api_get_ota(self, path: str) -> Optional[dict]:
+        try:
+            return await self.async_request(
+                path, self._session.get, allow_ota_check_response=True
+            )
+        except Exception as ex:
+            logger.error(f"EXCEPTION DURING API CALL: {ex}")
+            raise ex
+
     async def async_api_post(
         self, path: str, data: Union[dict, str, None]
     ) -> Optional[dict]:

{blebox_uniapi-2.5.2 → blebox_uniapi-2.5.4}/blebox_uniapi/switch.py

@@ -15,11 +15,13 @@ class Switch(Feature):
         methods: dict,
         dev_class: str,
         unit_id: Union[str, int, None] = 0,
+        name: Optional[str] = None,
     ):
         methods = self.resolve_access_method_paths(methods, str(unit_id))
         super().__init__(product, alias, methods)
         self._device_class = dev_class
         self._unit_id = unit_id
+        self._name = name
 
     @classmethod
     def many_from_config(
@@ -46,6 +48,7 @@ class Switch(Feature):
                         methods,
                         relay_type,
                         relay_id,
+                        name=relay.get("name"),
                     )
                 )
 
@@ -74,6 +77,14 @@ class Switch(Feature):
         unit = self._unit_id
         return [] if unit is None else [unit]
 
+    @property
+    def index(self) -> Optional[int]:
+        return self._unit_id
+
+    @property
+    def name(self) -> Optional[str]:
+        return self._name
+
     async def async_turn_on(self, **kwargs: Any) -> None:
         await self.async_api_command("on", *self._unit_args)
 

blebox_uniapi-2.5.4/blebox_uniapi/update.py

@@ -0,0 +1,23 @@
+from typing import Optional
+
+from .feature import Feature
+
+
+class Update(Feature):
+    @property
+    def installed_version(self) -> Optional[str]:
+        return self._product.firmware_version
+
+    @property
+    def latest_version(self) -> Optional[str]:
+        return self._product.available_firmware_version
+
+    async def async_update(self) -> None:
+        # OTA state is stored as Box attributes, not in last_data. async_update_data() won't trigger the OTA check.
+        await self._product.async_ota_check()
+
+    async def async_install(self) -> None:
+        await self._product.async_ota_update()
+
+    def after_update(self) -> None:
+        pass

{blebox_uniapi-2.5.2 → blebox_uniapi-2.5.4}/blebox_uniapi.egg-info/PKG-INFO

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

{blebox_uniapi-2.5.2 → blebox_uniapi-2.5.4}/blebox_uniapi.egg-info/SOURCES.txt

@@ -19,6 +19,7 @@ blebox_uniapi/light.py
 blebox_uniapi/sensor.py
 blebox_uniapi/session.py
 blebox_uniapi/switch.py
+blebox_uniapi/update.py
 blebox_uniapi.egg-info/PKG-INFO
 blebox_uniapi.egg-info/SOURCES.txt
 blebox_uniapi.egg-info/dependency_links.txt

{blebox_uniapi-2.5.2 → blebox_uniapi-2.5.4}/setup.cfg

@@ -1,5 +1,5 @@
 [bumpversion]
-current_version = 2.5.2
+current_version = 2.5.4
 commit = True
 tag = True
 

{blebox_uniapi-2.5.2 → blebox_uniapi-2.5.4}/setup.py

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

blebox_uniapi-2.5.2/blebox_uniapi/binary_sensor.py

@@ -1,96 +0,0 @@
-from typing import Union, TYPE_CHECKING
-
-from .feature import Feature
-
-if TYPE_CHECKING:
-    from .box import Box
-
-
-class BinarySensor(Feature):
-    """Class representing sensor with bool state."""
-
-    def __init__(self, product: "Box", alias: str, methods: dict):
-        super().__init__(product, alias, methods)
-
-    @classmethod
-    def many_from_config(
-        cls, product, box_type_config, extended_state
-    ) -> list["Feature"]:
-        type_class_map = {
-            "rain": Rain,
-            "flood": Flood,
-        }
-
-        output_list = list()
-        sensors_list = extended_state.get("multiSensor").get("sensors", {})
-        alias, methods = box_type_config[0]
-
-        for sensor in sensors_list:
-            sensor_type = sensor.get("type")
-            sensor_id = sensor.get("id")
-
-            if sensor_type in type_class_map:
-                klass = type_class_map[sensor_type]
-
-                if methods.get(sensor_type) is not None:
-                    value_method = {sensor_type: methods[sensor_type](sensor_id)}
-                    output_list.append(
-                        klass(
-                            product=product,
-                            alias=sensor_type + "_" + str(sensor_id),
-                            methods=value_method,
-                        )
-                    )
-
-        return output_list
-
-
-class Rain(BinarySensor):
-    def __init__(self, product: "Box", alias: str, methods: dict):
-        self._device_class = "moisture"
-        super().__init__(product, alias, methods)
-
-    @property
-    def state(self) -> bool:
-        return self._current > 0
-
-    @property
-    def device_class(self) -> str:
-        return self._device_class
-
-    def _read_rain(self, field: str) -> Union[float, int, None]:
-        product = self._product
-        if product.last_data is not None:
-            raw = self.raw_value(field)
-            if raw is not None:  # no reading
-                return self.raw_value("rain")
-        return 0
-
-    def after_update(self) -> None:
-        self._current = self._read_rain("rain")
-
-
-class Flood(BinarySensor):
-    def __init__(self, product: "Box", alias: str, methods: dict):
-        self._device_class = "moisture"
-        super().__init__(product, alias, methods)
-
-    @property
-    def state(self) -> bool:
-        return self._current > 0
-
-    @property
-    def device_class(self) -> str:
-        return self._device_class
-
-    def _read_flood(self, field: str) -> Union[float, int, None]:
-        product = self._product
-
-        if product.last_data is not None:
-            raw = self.raw_value(field)
-            if raw is not None:  # no reading
-                return self.raw_value("flood")
-        return 0
-
-    def after_update(self) -> None:
-        self._current = self._read_flood("flood")