blebox-uniapi 2.5.3__tar.gz → 2.5.5__tar.gz

{blebox_uniapi-2.5.3 → blebox_uniapi-2.5.5}/PKG-INFO

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

{blebox_uniapi-2.5.3 → blebox_uniapi-2.5.5}/blebox_uniapi/__init__.py

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

{blebox_uniapi-2.5.3 → blebox_uniapi-2.5.5}/blebox_uniapi/binary_sensor.py

@@ -9,7 +9,14 @@ if TYPE_CHECKING:
 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):
+    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)
@@ -60,7 +67,14 @@ class BinarySensor(Feature):
 
 
 class Rain(BinarySensor):
-    def __init__(self, product: "Box", alias: str, methods: dict, sensor_id: Optional[int] = None, name: Optional[str] = None):
+    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)
 
@@ -85,7 +99,14 @@ class Rain(BinarySensor):
 
 
 class Flood(BinarySensor):
-    def __init__(self, product: "Box", alias: str, methods: dict, sensor_id: Optional[int] = None, name: Optional[str] = None):
+    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)
 
@@ -111,9 +132,16 @@ class Flood(BinarySensor):
 
 
 class Open(BinarySensor):
-    def __init__(self, product: "Box", alias: str, methods: dict):
+    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)
+        super().__init__(product, alias, methods, sensor_id=sensor_id, name=name)
 
     @property
     def state(self) -> bool:
@@ -130,12 +158,19 @@ class Open(BinarySensor):
 
     def after_update(self) -> None:
         self._current = self._read_input("openStatus")
-        
-        
+
+
 class Input(BinarySensor):
-    def __init__(self, product: "Box", alias: str, methods: dict):
+    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)
+        super().__init__(product, alias, methods, sensor_id=sensor_id, name=name)
 
     @property
     def state(self) -> bool:

{blebox_uniapi-2.5.3 → blebox_uniapi-2.5.5}/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.3 → blebox_uniapi-2.5.5}/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
@@ -372,6 +380,36 @@ BOX_TYPE_CONF: dict[str, dict[int, dict[str, Any]]] = {
                 ]
             ],
         },
+        20220505: {
+            "api_path": "/state/extended",
+            "extended_state_path": "/state/extended",
+            "api": {
+                # note: old control api (i.e. /s/0, /s/1, /s/2) still supported but
+                # now deprecated. switchBox has now API consistent with switchBoxD
+                "on": lambda x=None: ("GET", f"/s/{x}/1", None),
+                "off": lambda x=None: ("GET", f"/s/{x}/0", None),
+            },
+            "switches": [
+                [
+                    "relay",
+                    {"state": lambda x: f"relays[?relay==`{x}`]|[0]|state"},
+                    "relay",
+                ]
+            ],
+            "sensors": [
+                [
+                    "switchBox.energy",
+                    {
+                        # note: switchbox/switchboxD sensors are currently not indexed (singletons)
+                        "powerConsumption": lambda x: "powerMeasuring.powerConsumption[0]|value ",
+                        "activePower": lambda x: "sensors[?type == 'activePower']|[0]|value",
+                        "voltage": lambda x: "sensors[?type == 'voltage']|[0]|value",
+                        "periodS": "powerMeasuring.powerConsumption[0]|periodS",
+                        "measurement_enabled": "powerMeasuring.enabled",
+                    },
+                ]
+            ],
+        },
     },
     # switchBoxD
     "switchBoxD": {
@@ -716,11 +754,15 @@ BOX_TYPE_CONF: dict[str, dict[int, dict[str, Any]]] = {
                         "reactivePower": lambda x: f"multiSensor.sensors[?id == `{x}`]|[?type == 'reactivePower']|[0]|value",
                         "reverseActiveEnergy": lambda x: f"multiSensor.sensors[?id == `{x}`]|[?type == 'reverseActiveEnergy']|[0]|value",
                         "forwardActiveEnergy": lambda x: f"multiSensor.sensors[?id == `{x}`]|[?type == 'forwardActiveEnergy']|[0]|value",
+                        "forwardReactiveEnergy": lambda x: f"multiSensor.sensors[?id == `{x}`]|[?type == 'forwardReactiveEnergy']|[0]|value",
+                        "reverseReactiveEnergy": lambda x: f"multiSensor.sensors[?id == `{x}`]|[?type == 'reverseReactiveEnergy']|[0]|value",
                         "illuminance": lambda x: f"multiSensor.sensors[?id == `{x}`]|[?type == 'illuminance']|[0]|value",
                         "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",
+                        "co2": lambda x: f"multiSensor.sensors[?id == `{x}`]|[?type == 'co2']|[0]|value",
+                        "co2Definition": lambda x: f"multiSensor.sensors[?id == `{x}`]|[?type == 'co2Definition']|[0]|value",
                     },
                 ]
             ],

{blebox_uniapi-2.5.3 → blebox_uniapi-2.5.5}/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):
@@ -92,7 +101,7 @@ class UnifiedCoverType(IntEnum):
 class Gate:
     _control_type: Optional[int]
 
-    def __init__(self, control_type: int):
+    def __init__(self, control_type: int, is_calibrated: bool = False):
         self._control_type = control_type
 
     def read_state(self, alias: str, raw_value: Any, product: "Box") -> int:
@@ -139,6 +148,10 @@ class Gate:
     def close_command(self) -> str:
         return "close"
 
+    @property
+    def is_calibrated(self) -> None:
+        return None
+
     def stop_command(self, has_stop: bool) -> str:
         return "stop"
 
@@ -148,6 +161,11 @@ class Gate:
 
 class Shutter(Gate):
     _control_type: Optional[ShutterBoxControlType]
+    _is_calibrated: bool
+
+    def __init__(self, control_type: int, is_calibrated: bool = False):
+        super().__init__(control_type)
+        self._is_calibrated = is_calibrated
 
     @property
     def min_position(self) -> int:
@@ -155,7 +173,42 @@ 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,
+            )
+            and self.is_calibrated is True
+        )
+
+    @property
+    def is_calibrated(self) -> bool:
+        return self._is_calibrated
 
     def read_cover_type(
         self, alias: str, raw_value: Any, product: "Box"
@@ -164,7 +217,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 +229,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):
@@ -301,13 +372,20 @@ class Cover(Feature):
         extended_state: dict,
     ) -> None:
         control_type = None
+        is_calibrated: bool = False
         if extended_state and issubclass(subclass, Shutter):
             control_type = extended_state.get("shutter", {}).get("controlType", None)
+            is_calibrated = bool(
+                extended_state.get("shutter", {})
+                .get("calibrationParameters", {})
+                .get("isCalibrated", False)
+            )
+
         elif extended_state and issubclass(subclass, GateBoxB):
             control_type = extended_state.get("gate", {}).get("openCloseMode", None)
 
         self._device_class = dev_class
-        self._attributes: GateT = subclass(control_type)
+        self._attributes: GateT = subclass(control_type, is_calibrated)
         self._tilt_current = None
         super().__init__(product, alias, methods)
 
@@ -329,6 +407,10 @@ class Cover(Feature):
     def tilt_current(self):
         return self._tilt_current
 
+    @property
+    def is_calibrated(self) -> Optional[bool]:
+        return self._attributes.is_calibrated
+
     @property
     def is_slider(self) -> Any:
         return self._attributes.is_slider
@@ -345,6 +427,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.3 → blebox_uniapi-2.5.5}/blebox_uniapi/light.py

@@ -280,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):
@@ -297,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:
@@ -310,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)]
@@ -356,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]:
@@ -374,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]
@@ -451,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:
@@ -518,7 +547,11 @@ class Light(Feature):
                 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)
@@ -529,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.3 → blebox_uniapi-2.5.5}/blebox_uniapi/sensor.py

@@ -160,12 +160,16 @@ class BaseSensor(Feature):
 @SensorFactory.register("apparentPower", unit="va")
 @SensorFactory.register("reactivePower", unit="var")
 @SensorFactory.register("activePower", unit="W")
+@SensorFactory.register("reverseReactiveEnergy", unit="kvarh", scale=1_000)
+@SensorFactory.register("forwardReactiveEnergy", unit="kvarh", scale=1_000)
 @SensorFactory.register("reverseActiveEnergy", unit="kWh", scale=1_000)
 @SensorFactory.register("forwardActiveEnergy", unit="kWh", scale=1_000)
 @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="")
+@SensorFactory.register("co2", unit="ppm")
+@SensorFactory.register("co2Definition", unit="")
 class GenericSensor(BaseSensor):
     def __init__(
         # base sensor params

{blebox_uniapi-2.5.3 → blebox_uniapi-2.5.5}/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.5/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.3 → blebox_uniapi-2.5.5}/blebox_uniapi.egg-info/PKG-INFO

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

{blebox_uniapi-2.5.3 → blebox_uniapi-2.5.5}/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.3 → blebox_uniapi-2.5.5}/setup.cfg

@@ -1,5 +1,5 @@
 [bumpversion]
-current_version = 2.5.3
+current_version = 2.5.5
 commit = True
 tag = True
 

{blebox_uniapi-2.5.3 → blebox_uniapi-2.5.5}/setup.py

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