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

{blebox_uniapi-2.5.5 → blebox_uniapi-2.5.7}/CONTRIBUTING.rst

@@ -122,7 +122,11 @@ Make sure all your changes are committed (including an entry in HISTORY.rst).
 Then run::
 
 $ bump2version patch # possible: major / minor / patch
-$ git push
-$ git push --tags
-
-Travis will then deploy to PyPI if tests pass.
+$ git push --follow-tags
+
+bump2version bumps the version in setup.py, blebox_uniapi/__init__.py and
+setup.cfg, commits the change and creates a matching git tag (e.g. v2.6.0).
+Pushing the tag triggers the "Publish to PyPI" GitHub Actions workflow
+(.github/workflows/release.yml), which first runs lint + tests, then builds and
+uploads to PyPI via Trusted Publishing (OIDC) from the blebox/blebox_uniapi repo.
+The publish step only runs if the tests pass.

{blebox_uniapi-2.5.5 → blebox_uniapi-2.5.7}/MANIFEST.in

@@ -1,4 +1,3 @@
-include AUTHORS.rst
 include CONTRIBUTING.rst
 include HISTORY.rst
 include LICENSE

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

@@ -1,22 +1,36 @@
-Metadata-Version: 2.1
+Metadata-Version: 2.4
 Name: blebox_uniapi
-Version: 2.5.5
+Version: 2.5.7
 Summary: Python API for accessing BleBox smart home devices
 Home-page: https://github.com/blebox/blebox_uniapi
 Author: BleBox
 Author-email: opensource@blebox.eu
 License: Apache Software License 2.0
 Keywords: blebox_uniapi
-Platform: UNKNOWN
 Classifier: Development Status :: 2 - Pre-Alpha
 Classifier: Intended Audience :: Developers
 Classifier: License :: OSI Approved :: Apache Software License
 Classifier: Natural Language :: English
 Classifier: Programming Language :: Python :: 3.9
 Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
 Requires-Python: >=3.9
 Description-Content-Type: text/x-rst
 License-File: LICENSE
+Requires-Dist: aiohttp>=3
+Requires-Dist: jmespath>1.0.0
+Dynamic: author
+Dynamic: author-email
+Dynamic: classifier
+Dynamic: description
+Dynamic: description-content-type
+Dynamic: home-page
+Dynamic: keywords
+Dynamic: license
+Dynamic: license-file
+Dynamic: requires-dist
+Dynamic: requires-python
+Dynamic: summary
 
 ====================
 BleBox Python UniAPI
@@ -227,5 +241,3 @@ History
 ------------------
 
 * First release on PyPI.
-
-

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

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

{blebox_uniapi-2.5.5 → blebox_uniapi-2.5.7}/blebox_uniapi/box.py

@@ -111,6 +111,7 @@ class Box:
 
         self._data_path = config["api_path"]
         self._type = type
+        self._product = product
         self._unique_id = unique_id
         self._name = name
         self._address = address
@@ -212,6 +213,11 @@ class Box:
     def type(self) -> str:
         return self._type
 
+    @property
+    def product(self) -> str:
+        """Product name for informational purpose only - do not use it in any application logic."""
+        return self._product
+
     @property
     def unique_id(self) -> Any:
         return self._unique_id

{blebox_uniapi-2.5.5 → blebox_uniapi-2.5.7}/blebox_uniapi/box_types.py

@@ -1,3 +1,4 @@
+from .button import GateBoxSecondOutput, TvLift
 from .cover import Gate, GateBox, GateBoxB, Shutter
 from typing import Union, Any
 
@@ -50,9 +51,8 @@ BOX_TYPE_CONF: dict[str, dict[int, dict[str, Any]]] = {
                 "set": lambda command: ("GET", f"/s/c/{command}")
             },  # dictionary with interaction methods
             "buttons": [
-                "tvLift",
-                {"lift": ""},
-            ],  # key used to set platform, list elements used in cls init, e.g. [<alias>, {"path": "state_value"}]
+                ["tvLift", {}, TvLift],
+            ],  # key used to set platform, list elements used in cls init, e.g. [<alias>, {"path": "state_value"}, <optional type class>]
         }
     },
     # airSensor
@@ -135,11 +135,15 @@ BOX_TYPE_CONF: dict[str, dict[int, dict[str, Any]]] = {
                     {
                         "position": "gate.currentPos",
                         "gate_type": "gate.gateType",
+                        "extra_button_type": "gate.extraButtonType",
                     },
                     "gatebox",
                     GateBoxB,
                 ]
             ],
+            "buttons": [
+                ["second_output", {}, GateBoxSecondOutput],
+            ],
         },
     },
     # gateController
@@ -187,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",
@@ -199,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",
                     },
                 ]
             ],
@@ -526,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",
                     },
                 ]
@@ -678,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",
                     },
                 ]
             ],
@@ -700,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",
                     },
                 ]
             ],
@@ -723,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",
                     },
                 ]
             ],
@@ -747,22 +762,39 @@ 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",
                     },
                 ]
             ],

blebox_uniapi-2.5.7/blebox_uniapi/button.py

@@ -0,0 +1,141 @@
+from .cover import GateBoxControlType, GateBoxExtraButtonType
+from .feature import Feature
+from typing import TYPE_CHECKING, Any, Optional, Type
+
+from enum import Enum, auto
+
+if TYPE_CHECKING:
+    from .box import Box
+
+TV_LIFT_CONTROL_TYPES_API = {
+    0: {"1": "open_or_stop", "2": "close_or_stop"},
+    1: {"1": "up_or_stop", "2": "down_or_stop"},
+    2: {"1": "up_or_stop", "2": "down_or_stop"},
+    3: {"1": "up_or_stop", "2": "down_or_stop"},
+    4: {"1": "open_or_stop", "2": "close_or_stop", "3": "to_fav"},
+}
+
+
+class ControlType(Enum):
+    UP = auto()
+    DOWN = auto()
+    FAVORITE = auto()
+    OPEN = auto()
+    CLOSE = auto()
+
+
+class Buttons:
+    """Buttons defines how a product derives its buttons from extended state."""
+
+    @staticmethod
+    def many_from_extended_state(
+        button_cls: Type["Button"],
+        product: "Box",
+        alias: str,
+        methods: dict,
+        extended_state: dict,
+    ) -> list["Button"]:
+        raise NotImplementedError  # pragma: no cover
+
+
+class TvLift(Buttons):
+    @staticmethod
+    def many_from_extended_state(
+        button_cls: Type["Button"],
+        product: "Box",
+        alias: str,
+        methods: dict,
+        extended_state: dict,
+    ) -> list["Button"]:
+        control_type = extended_state.get("tvLift", {}).get("controlType")
+        endpoints = TV_LIFT_CONTROL_TYPES_API.get(control_type, {})
+        return [
+            button_cls(product, f"{alias}_{endpoint}", methods, endpoint)
+            for endpoint in endpoints.values()
+        ]
+
+
+class GateBoxSecondOutput(Buttons):
+    """GateBoxSecondOutput exposes the gateBox extra button output as a button.
+
+    WALK_IN and OTHER share one button name because what the output does is a
+    device setting the user can change at any time, not a hardware trait.
+    """
+
+    @staticmethod
+    def many_from_extended_state(
+        button_cls: Type["Button"],
+        product: "Box",
+        alias: str,
+        methods: dict,
+        extended_state: dict,
+    ) -> list["Button"]:
+        gate = extended_state.get("gate", {})
+        if gate.get("extraButtonType") not in (
+            GateBoxExtraButtonType.WALK_IN,
+            GateBoxExtraButtonType.OTHER,
+        ):
+            return []
+
+        # Api levels below 20230102 report no mode and cannot be wired that way.
+        if gate.get("openCloseMode") == GateBoxControlType.OPEN_CLOSE:
+            return []
+
+        return [button_cls(product, alias, methods, "second_output", "secondary")]
+
+
+class Button(Feature):
+    def __init__(
+        self,
+        product: "Box",
+        alias: str,
+        methods: dict,
+        query_string: str,
+        api_command: str = "set",
+    ) -> None:
+        super().__init__(product, alias, methods)
+        self._device_class = "UPDATE"
+        self._query_string: str = query_string
+        self._api_command: str = api_command
+
+    @classmethod
+    def many_from_config(
+        cls, product: "Box", box_type_config: list, extended_state: Any
+    ) -> list["Button"]:
+        if not isinstance(extended_state, dict):
+            return []
+
+        features: list[Button] = []
+        for alias, methods, buttons in box_type_config:
+            features.extend(
+                buttons.many_from_extended_state(
+                    cls, product, alias, methods, extended_state
+                )
+            )
+        return features
+
+    async def set(self) -> None:
+        await self.async_api_command(self._api_command, self.query_string)
+
+    def after_update(self) -> None:
+        pass
+
+    @property
+    def control_type(self) -> Optional[ControlType]:
+        """Return icon for endpoint."""
+        if "up" in self.query_string:
+            return ControlType.UP
+        elif "down" in self.query_string:
+            return ControlType.DOWN
+        elif "fav" in self.query_string:
+            return ControlType.FAVORITE
+        elif "open" in self.query_string:
+            return ControlType.OPEN
+        elif "close" in self.query_string:
+            return ControlType.CLOSE
+        else:
+            return None
+
+    @property
+    def query_string(self) -> str:
+        return self._query_string

{blebox_uniapi-2.5.5 → blebox_uniapi-2.5.7}/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.5 → blebox_uniapi-2.5.7}/blebox_uniapi/cover.py

@@ -65,6 +65,19 @@ class GateBoxControlType(IntEnum):
     OPEN_CLOSE = 2
 
 
+class GateBoxExtraButtonType(IntEnum):
+    """GateBoxExtraButtonType defines gateBox extra button semantics.
+
+    Only meaningful outside OPEN_CLOSE mode, which takes the extra button output
+    for the close action and leaves this field unused.
+    """
+
+    DISABLED = 0
+    STOP = 1
+    WALK_IN = 2
+    OTHER = 3
+
+
 class GateBoxGateType(IntEnum):
     """GateBoxGateType defines possible gate/cover types reported by gateBox"""
 
@@ -305,7 +318,7 @@ class GateBox(Gate):
         if button_type is None:
             return False
 
-        return button_type == 1
+        return button_type == GateBoxExtraButtonType.STOP
 
 
 class GateBoxB(GateBox):
@@ -328,9 +341,23 @@ class GateBoxB(GateBox):
         return raw_value("position")
 
     def read_has_stop(self, alias: str, raw_value: Any, product: "Box") -> bool:
+        if product.last_data is None:
+            return False
+
         # note: if control type is unknown we assume it is not open/close
         #       and has the stop feature via secondary button command.
-        return self._control_type != GateBoxControlType.OPEN_CLOSE
+        if self._control_type == GateBoxControlType.OPEN_CLOSE:
+            return False
+
+        # stop_command issues the same secondary command as the second_output button.
+        extra_button_type = raw_value("extra_button_type")
+        if extra_button_type in (
+            GateBoxExtraButtonType.WALK_IN,
+            GateBoxExtraButtonType.OTHER,
+        ):
+            return False
+
+        return True
 
     def read_cover_type(
         self, alias: str, raw_value: Any, product: "Box"

{blebox_uniapi-2.5.5 → blebox_uniapi-2.5.7}/blebox_uniapi/error.py

@@ -39,7 +39,6 @@ class UnsupportedBoxVersion(BoxError):
     pass
 
 
-
 class BadFieldExceedsMax(BoxError):
     def __init__(self, dev_name: str, field: str, value: int, max_value: int):
         self._dev_name = dev_name
@@ -103,7 +102,6 @@ class BadFieldNotRGBW(BoxError):
         return f"{self._dev_name}.{self._field} is {self._value} which is not a rgbw string"
 
 
-
 # misc errors