livisi 0.0.24__py3-none-any.whl → 0.9.0__py3-none-any.whl

livisi/livisi_device.py

@@ -0,0 +1,53 @@
+"""Code to represent a livisi device."""
+
+from __future__ import annotations
+from typing import Any
+
+from dataclasses import dataclass
+
+from .livisi_const import CONTROLLER_DEVICE_TYPES
+
+
+@dataclass
+class LivisiDevice:
+    """Stores the livisi device data."""
+
+    id: str
+    type: str
+    tags: dict[str, str]
+    config: dict[str, Any]
+    state: dict[str, Any]
+    manufacturer: str
+    version: str
+    cls: str
+    product: str
+    desc: str
+    capabilities: dict[str, str]
+    capability_config: dict[str, dict[str, Any]]
+    room: str
+    battery_low: bool
+    update_available: bool
+    updated: bool
+    unreachable: bool
+
+    @property
+    def name(self) -> str:
+        """Get name from config."""
+        return self.config.get("name")
+
+    @property
+    def tag_category(self) -> str:
+        """Get tag type category from config."""
+        if self.tags is None:
+            return None
+        return self.tags.get("typeCategory")
+
+    @property
+    def tag_type(self) -> str:
+        """Get tag type from config."""
+        return self.tags.get("type")
+
+    @property
+    def is_shc(self) -> bool:
+        """Indicate whether this device is the controller."""
+        return self.type in CONTROLLER_DEVICE_TYPES

livisi/livisi_errors.py

@@ -0,0 +1,124 @@
+"""Errors for the Livisi Smart Home component."""
+
+# Taken from https://developer.services-smarthome.de/api_reference/errorcodes/
+ERROR_CODES = {
+    # General Errors
+    1000: "An unknown error has occurred.",
+    1001: "Service unavailable.",
+    1002: "Service timeout.",
+    1003: "Internal API error.",
+    1004: "SHC invalid operation.",
+    1005: "Missing argument or wrong value.",
+    1006: "Service too busy.",
+    1007: "Unsupported request.",
+    1008: "Precondition failed.",
+    # Authentication and Authorization Errors
+    2000: "An unknown error has occurred during Authentication or Authorization process.",
+    2001: "Access not allowed.",
+    2002: "Invalid token request.",
+    2003: "Invalid client credentials.",
+    2004: "The token signature is invalid.",
+    2005: "Failed to initialize user session.",
+    2006: "A connection already exists for the current session.",
+    2007: "The lifetime of the token has expired.",
+    2008: "Login attempted from a different client provider.",
+    2009: "Invalid user credentials.",
+    2010: "Controller access not allowed.",
+    2011: "Insufficient permissions.",
+    2012: "Session not found.",
+    2013: "Account temporary locked.",
+    # Entities Errors
+    3000: "The requested entity does not exist.",
+    3001: "The provided request content is invalid and can't be parsed.",
+    3002: "No change performed.",
+    3003: "The provided entity already exists.",
+    3004: "The provided interaction is not valid.",
+    3005: "Too many entities of this type.",
+    # Products Errors
+    3500: "Premium Services can't be directly enabled.",
+    3501: "Cannot remove a product that was paid.",
+    # Actions Errors
+    4000: "The triggered action is invalid.",
+    4001: "Invalid parameter.",
+    4002: "Permission to trigger action not allowed.",
+    4003: "Unsupported action type.",
+    # Configuration Errors
+    5000: "The configuration could not be updated.",
+    5001: "Could not obtain exclusive access on the configuration.",
+    5002: "Communication with the SHC failed.",
+    5003: "The owner did not accept the TaC latest version.",
+    5004: "One SHC already registered.",
+    5005: "The user has no SHC.",
+    5006: "Controller offline.",
+    5009: "Registration failure.",
+    # SmartCodes Errors
+    6000: "SmartCode request not allowed.",
+    6001: "The SmartCode cannot be redeemed.",
+    6002: "Restricted access.",
+}
+
+
+class LivisiException(Exception):
+    """Base class for Livisi exceptions."""
+
+    def __init__(self, message: str = "", *args: object) -> None:
+        """Initialize the exception with a message."""
+        self.message = message
+        super().__init__(message, *args)
+
+
+class ShcUnreachableException(LivisiException):
+    """Unable to connect to the Smart Home Controller."""
+
+    def __init__(
+        self,
+        message: str = "Unable to connect to the Smart Home Controller.",
+        *args: object,
+    ) -> None:
+        """Generate error with default message."""
+        super().__init__(message, *args)
+
+
+class WrongCredentialException(LivisiException):
+    """The user credentials were wrong."""
+
+    def __init__(
+        self, message: str = "The user credentials are wrong.", *args: object
+    ) -> None:
+        """Generate error with default message."""
+        super().__init__(message, *args)
+
+
+class IncorrectIpAddressException(LivisiException):
+    """The IP address provided by the user is incorrect."""
+
+    def __init__(
+        self,
+        message: str = "The IP address provided by the user is incorrect.",
+        *args: object,
+    ) -> None:
+        """Generate error with default message."""
+        super().__init__(message, *args)
+
+
+class TokenExpiredException(LivisiException):
+    """The authentication token is expired."""
+
+    def __init__(
+        self, message: str = "The authentication token is expired.", *args: object
+    ) -> None:
+        """Generate error with default message."""
+        super().__init__(message, *args)
+
+
+class ErrorCodeException(LivisiException):
+    """The request sent an errorcode (other than token expired) as response."""
+
+    def __init__(self, error_code: int, message: str = None, *args: object) -> None:
+        """Generate error with code."""
+        self.error_code = error_code
+        if (message is None) and (error_code in ERROR_CODES):
+            message = ERROR_CODES[error_code]
+        elif message is None:
+            message = f"Unknown error code from shc: {error_code}"
+        super().__init__(message, *args)

livisi/livisi_json_util.py

@@ -0,0 +1,23 @@
+"""Helper code to parse json to python dataclass (simple and non recursive)."""
+from dataclasses import fields
+import json
+import re
+
+
+def parse_dataclass(jsondata, clazz):
+    """Convert keys to snake_case and parse to dataclass."""
+
+    if isinstance(jsondata, str | bytes | bytearray):
+        parsed_json = json.loads(jsondata)
+    elif isinstance(jsondata, dict):
+        parsed_json = jsondata
+    else:
+        parsed_json = {}
+
+    # Convert keys to snake_case
+    parsed_json = {
+        re.sub("([A-Z])", r"_\1", k).lower(): v for k, v in parsed_json.items()
+    }
+    # Only include keys that are fields in the dataclass
+    data_dict = {f.name: parsed_json.get(f.name) for f in fields(clazz)}
+    return clazz(**data_dict)

livisi/livisi_websocket.py

@@ -0,0 +1,86 @@
+"""Code for communication with the Livisi application websocket."""
+
+from collections.abc import Callable
+import urllib.parse
+
+from json import JSONDecodeError
+import websockets.client
+
+from .livisi_json_util import parse_dataclass
+from .livisi_const import CLASSIC_WEBSOCKET_PORT, V2_WEBSOCKET_PORT, LOGGER
+from .livisi_websocket_event import LivisiWebsocketEvent
+
+
+class LivisiWebsocket:
+    """Represents the websocket class."""
+
+    def __init__(self, aiolivisi) -> None:
+        """Initialize the websocket."""
+        self.aiolivisi = aiolivisi
+        self.connection_url: str = None
+        self._websocket = None
+        self._disconnecting = False
+
+    def is_connected(self):
+        """Return whether the webservice is currently connected."""
+        return self._websocket is not None
+
+    async def connect(self, on_data, on_close) -> None:
+        """Connect to the socket."""
+        if self.aiolivisi.controller.is_v2:
+            port = V2_WEBSOCKET_PORT
+            token = urllib.parse.quote(self.aiolivisi.token)
+        else:
+            port = CLASSIC_WEBSOCKET_PORT
+            token = self.aiolivisi.token
+        ip_address = self.aiolivisi.host
+        self.connection_url = f"ws://{ip_address}:{port}/events?token={token}"
+
+        while not self._disconnecting:
+            try:
+                async with websockets.client.connect(
+                    self.connection_url, ping_interval=10, ping_timeout=10
+                ) as websocket:
+                    LOGGER.info("WebSocket connection established.")
+                    self._websocket = websocket
+                    await self.consumer_handler(websocket, on_data)
+            except Exception as e:
+                LOGGER.exception("Error handling websocket connection", exc_info=e)
+                if not self._disconnecting:
+                    LOGGER.warning("WebSocket disconnected unexpectedly, retrying...")
+                    await on_close()
+            finally:
+                self._websocket = None
+
+    async def disconnect(self) -> None:
+        """Close the websocket."""
+        self._disconnecting = True
+        if self._websocket is not None:
+            await self._websocket.close(code=1000, reason="Handle disconnect request")
+            LOGGER.info("WebSocket connection closed.")
+            self._websocket = None
+        self._disconnecting = False
+
+    async def consumer_handler(self, websocket, on_data: Callable):
+        """Parse data transmitted via the websocket."""
+        try:
+            async for message in websocket:
+                LOGGER.debug("Received WebSocket message: %s", message)
+
+                try:
+                    event_data = parse_dataclass(message, LivisiWebsocketEvent)
+                except JSONDecodeError:
+                    LOGGER.warning("Cannot decode WebSocket message", exc_info=True)
+                    continue
+
+                if event_data.properties is None or event_data.properties == {}:
+                    LOGGER.warning("Received event with no properties, skipping.")
+                    continue
+
+                # Remove the URL prefix and use just the ID (which is unique)
+                event_data.source = event_data.source.removeprefix("/device/")
+                event_data.source = event_data.source.removeprefix("/capability/")
+
+                on_data(event_data)
+        except Exception as e:
+            LOGGER.error("Unhandled error in WebSocket consumer handler", exc_info=e)

livisi/livisi_websocket_event.py

@@ -0,0 +1,13 @@
+"""LivisiWebsocketEvent."""
+from dataclasses import dataclass
+
+
+@dataclass
+class LivisiWebsocketEvent:
+    """Encapuses a livisi event sent via the websocket."""
+
+    namespace: str
+    type: str | None
+    source: str
+    timestamp: str | None
+    properties: dict | None

livisi-0.9.0.dist-info/METADATA

@@ -0,0 +1,26 @@
+Metadata-Version: 2.2
+Name: livisi
+Version: 0.9.0
+Summary: Connection library for the abandoned Livisi Smart Home system
+Author-email: Felix Rotthowe <felix@planbnet.org>
+License: Apache-2.0
+Project-URL: Source, https://github.com/planbnet/livisi
+Project-URL: Tracker, https://github.com/planbnet/livisi/issues
+Classifier: Programming Language :: Python :: 3
+Classifier: License :: OSI Approved :: Apache Software License
+Classifier: Operating System :: OS Independent
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: colorlog>=6.8.2
+Requires-Dist: aiohttp>=3.8.5
+Requires-Dist: websockets>=11.0.3
+
+# livisi
+
+# Asynchronous library to communicate with LIVISI Smart Home Controller
+Requires Python 3.10+ (might work with versions down to 3.8 but I never tested it) and uses asyncio and aiohttp.
+
+This library started as a fork of the unmaintained aiolivisi lib and was developed inside the [unofficial livisi integration for Home Assistant](https://github.com/planbnet/livisi_unofficial)
+
+The versions starting with `0.0.` are still compatible to the old aiolivisi code, while `1.0.0` will introduce lots of breaking changes besides support for more devices and improved connection stability and error handling.

livisi-0.9.0.dist-info/RECORD

@@ -0,0 +1,15 @@
+livisi/__init__.py,sha256=Dh8B_PRVSmch_ClhFCVyV7O2doRCfREHvKGob6MYuRk,2225
+livisi/livisi_connector.py,sha256=VagZFl46y49d3gqrr9iv0YSKLviHRLvAAxcMW4IO734,18095
+livisi/livisi_const.py,sha256=6YqoPdlKX7ogfC_E_ea8opA0JeYIweXRRfpfu-QXTqc,779
+livisi/livisi_controller.py,sha256=XyJ58XMXIxw5anIwHJ5MRVlNUBZyi3RjP8AO8HnYcXo,296
+livisi/livisi_device.py,sha256=Qeh8kdVWY57S1aS5S4ATfi8t2a2k0Bx6njScRC0XKek,1230
+livisi/livisi_errors.py,sha256=N-xEF42KfsCVUghdJYuM8yvpUiI_op1i1mpBiKcrM5Y,4511
+livisi/livisi_event.py,sha256=Z3VN1nW737O1xMt1yj62lC0KTiiXFIlRPEog33IsJpw,456
+livisi/livisi_json_util.py,sha256=6sQk8ycMUIAKL_8rD3dW_uHWRNa6QMcky-PvcEnM_88,735
+livisi/livisi_websocket.py,sha256=KFY_n7w0grwnczjUDrdijK4RQi-8MOX81uLe6Nw-mSM,3465
+livisi/livisi_websocket_event.py,sha256=pbjyiKid9gOWMcWiw5jq0dbo2DQ7dAQnxM0D_UJBltw,273
+livisi-0.9.0.dist-info/LICENSE,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+livisi-0.9.0.dist-info/METADATA,sha256=iIyRLOhx8GWwodC5quOjI1tPK2irJyNjkuYzS0PaWVA,1263
+livisi-0.9.0.dist-info/WHEEL,sha256=52BFRY2Up02UkjOa29eZOS2VxUrpPORXg1pkohGGUS8,91
+livisi-0.9.0.dist-info/top_level.txt,sha256=ctiU5MMpBSwoQR7mJWIuyB1ND1_g004Xa3vNmMsSiCs,7
+livisi-0.9.0.dist-info/RECORD,,

{livisi-0.0.24.dist-info → livisi-0.9.0.dist-info}/WHEEL

@@ -1,5 +1,5 @@
 Wheel-Version: 1.0
-Generator: setuptools (75.6.0)
+Generator: setuptools (76.0.0)
 Root-Is-Purelib: true
 Tag: py3-none-any
 

livisi/aiolivisi.py

@@ -1,270 +0,0 @@
-"""Code to handle the communication with Livisi Smart home controllers."""
-from __future__ import annotations
-from typing import Any
-import uuid
-
-from aiohttp.client import ClientSession
-
-from .errors import (
-    IncorrectIpAddressException,
-    ShcUnreachableException,
-    WrongCredentialException,
-    TokenExpiredException,
-)
-
-from .const import (
-    AUTH_GRANT_TYPE,
-    AUTH_PASSWORD,
-    AUTH_USERNAME,
-    AUTHENTICATION_HEADERS,
-    CLASSIC_PORT,
-    LOCATION,
-    CAPABILITY_MAP,
-    CAPABILITY_CONFIG,
-    REQUEST_TIMEOUT,
-    USERNAME,
-)
-
-ERRORS = {1: Exception}
-
-
-class AioLivisi:
-    """Handles the communication with the Livisi Smart Home controller."""
-
-    instance = None
-
-    def __init__(
-        self, web_session: ClientSession = None, auth_headers: dict[str, Any] = None
-    ) -> None:
-        self._web_session: ClientSession = web_session
-        self._auth_headers: dict[str, Any] = auth_headers
-        self._token: str = ""
-        self._livisi_connection_data: dict[str, str] = None
-
-    async def async_set_token(
-        self, livisi_connection_data: dict[str, str] = None
-    ) -> None:
-        """Set the JWT from the LIVISI Smart Home Controller."""
-        access_data: dict = {}
-        try:
-            if self._livisi_connection_data is not None:
-                self._livisi_connection_data = livisi_connection_data
-            access_data = await self.async_get_jwt_token(livisi_connection_data)
-            self.token = access_data["access_token"]
-            self._auth_headers = {
-                "authorization": f"Bearer {self.token}",
-                "Content-type": "application/json",
-                "Accept": "*/*",
-            }
-        except Exception as error:
-            if len(access_data) == 0:
-                raise IncorrectIpAddressException from error
-            elif access_data["errorcode"] == 2009:
-                raise WrongCredentialException from error
-            else:
-                raise ShcUnreachableException from error
-
-    async def async_send_authorized_request(
-        self,
-        method,
-        url: str,
-        payload=None,
-    ) -> dict:
-        """Make a request to the Livisi Smart Home controller."""
-        ip_address = self._livisi_connection_data["ip_address"]
-        path = f"http://{ip_address}:{CLASSIC_PORT}/{url}"
-        return await self.async_send_request(method, path, payload, self._auth_headers)
-
-    async def async_send_unauthorized_request(
-        self,
-        method,
-        url: str,
-        headers,
-        payload=None,
-    ) -> dict:
-        """Send a request without JWT token."""
-        return await self.async_send_request(method, url, payload, headers)
-
-    async def async_get_jwt_token(self, livisi_connection_data: dict[str, str]):
-        """Send a request for getting the JWT token."""
-        login_credentials = {
-            AUTH_USERNAME: USERNAME,
-            AUTH_PASSWORD: livisi_connection_data["password"],
-            AUTH_GRANT_TYPE: "password",
-        }
-        headers = AUTHENTICATION_HEADERS
-        self._livisi_connection_data = livisi_connection_data
-        ip_address = self._livisi_connection_data["ip_address"]
-        return await self.async_send_request(
-            "post",
-            url=f"http://{ip_address}:{CLASSIC_PORT}/auth/token",
-            payload=login_credentials,
-            headers=headers,
-        )
-
-    async def async_send_request(
-        self, method, url: str, payload=None, headers=None
-    ) -> dict:
-        """Send a request to the Livisi Smart Home controller."""
-        try:
-            response = await self.__async_send_request(method, url, payload, headers)
-        except Exception:
-            response = await self.__async_send_request(method, url, payload, headers)
-            if "errorcode" in response:
-                if response["errorcode"] == 2007:
-                    raise TokenExpiredException
-        return response
-
-    async def __async_send_request(
-        self, method, url: str, payload=None, headers=None
-    ) -> dict:
-        async with self._web_session.request(
-            method,
-            url,
-            json=payload,
-            headers=headers,
-            ssl=False,
-            timeout=REQUEST_TIMEOUT,
-        ) as res:
-            data = await res.json()
-            return data
-
-    async def async_get_controller(self) -> dict[str, Any]:
-        """Get Livisi Smart Home controller data."""
-        return await self.async_get_controller_status()
-
-    async def async_get_controller_status(self) -> dict[str, Any]:
-        """Get Livisi Smart Home controller status."""
-        shc_info = await self.async_send_authorized_request("get", url="status")
-        return shc_info
-
-    async def async_get_devices(
-        self,
-    ) -> list[dict[str, Any]]:
-        """Send a request for getting the devices."""
-        devices = await self.async_send_authorized_request("get", url="device")
-        capabilities = await self.async_send_authorized_request("get", url="capability")
-
-        capability_map = {}
-        capability_config = {}
-
-        for capability in capabilities:
-            if "device" in capability:
-                device_id = capability["device"].split("/")[-1]
-                if device_id not in capability_map:
-                    capability_map[device_id] = {}
-                    capability_config[device_id] = {}
-                capability_map[device_id][capability["type"]] = (
-                    "/capability/" + capability["id"]
-                )
-            if "config" in capability:
-                capability_config[device_id][capability["type"]] = capability["config"]
-
-        for device in devices:
-            device_id = device["id"]
-            device[CAPABILITY_MAP] = capability_map.get(device_id, {})
-            device[CAPABILITY_CONFIG] = capability_config.get(device_id, {})
-
-        for device in devices.copy():
-            if LOCATION in device and device.get(LOCATION) is not None:
-                device[LOCATION] = device[LOCATION].removeprefix("/location/")
-        return devices
-
-    async def async_get_device_state(self, capability) -> dict[str, Any] | None:
-        """Get the state of the device."""
-        url = f"{capability}/state"
-        try:
-            return await self.async_send_authorized_request("get", url)
-        except Exception:
-            return None
-
-    async def async_pss_set_state(self, capability_id, is_on: bool) -> dict[str, Any]:
-        """Set the PSS state."""
-        set_state_payload: dict[str, Any] = {
-            "id": uuid.uuid4().hex,
-            "type": "SetState",
-            "namespace": "core.RWE",
-            "target": capability_id,
-            "params": {"onState": {"type": "Constant", "value": is_on}},
-        }
-        return await self.async_send_authorized_request(
-            "post", "action", payload=set_state_payload
-        )
-
-    async def async_set_onstate(self, capability_id, is_on: bool) -> dict[str, Any]:
-        """Set the onState for devices that support it."""
-        set_state_payload: dict[str, Any] = {
-            "id": uuid.uuid4().hex,
-            "type": "SetState",
-            "namespace": "core.RWE",
-            "target": capability_id,
-            "params": {"onState": {"type": "Constant", "value": is_on}},
-        }
-        return await self.async_send_authorized_request(
-            "post", "action", payload=set_state_payload
-        )
-
-    async def async_variable_set_value(
-        self, capability_id, value: bool
-    ) -> dict[str, Any]:
-        """Set the boolean variable state."""
-        set_value_payload: dict[str, Any] = {
-            "id": uuid.uuid4().hex,
-            "type": "SetState",
-            "namespace": "core.RWE",
-            "target": capability_id,
-            "params": {"value": {"type": "Constant", "value": value}},
-        }
-        return await self.async_send_authorized_request(
-            "post", "action", payload=set_value_payload
-        )
-
-    async def async_vrcc_set_temperature(
-        self, capability_id, target_temperature: float, is_avatar: bool
-    ) -> dict[str, Any]:
-        """Set the Virtual Climate Control state."""
-        if is_avatar:
-            params = "setpointTemperature"
-        else:
-            params = "pointTemperature"
-        set_state_payload: dict[str, Any] = {
-            "id": uuid.uuid4().hex,
-            "type": "SetState",
-            "namespace": "core.RWE",
-            "target": capability_id,
-            "params": {params: {"type": "Constant", "value": target_temperature}},
-        }
-        return await self.async_send_authorized_request(
-            "post", "action", payload=set_state_payload
-        )
-
-    async def async_get_all_rooms(self) -> dict[str, Any]:
-        """Get all the rooms from LIVISI configuration."""
-        return await self.async_send_authorized_request("get", "location")
-
-    @property
-    def livisi_connection_data(self):
-        """Return the connection data."""
-        return self._livisi_connection_data
-
-    @livisi_connection_data.setter
-    def livisi_connection_data(self, new_value):
-        self._livisi_connection_data = new_value
-
-    @property
-    def token(self):
-        """Return the token."""
-        return self._token
-
-    @token.setter
-    def token(self, new_value):
-        self._token = new_value
-
-    @property
-    def web_session(self):
-        """Return the web session."""
-        return self._web_session
-
-    @web_session.setter
-    def web_session(self, new_value):
-        self._web_session = new_value

livisi/const.py

@@ -1,40 +0,0 @@
-from typing import Final
-
-
-CLASSIC_PORT: Final = 8080
-AVATAR_PORT: Final = 9090
-USERNAME: Final = "admin"
-AUTH_USERNAME: Final = "username"
-AUTH_PASSWORD: Final = "password"
-AUTH_GRANT_TYPE: Final = "grant_type"
-REQUEST_TIMEOUT: Final = 2000
-
-ON_STATE: Final = "onState"
-VALUE: Final = "value"
-POINT_TEMPERATURE: Final = "pointTemperature"
-SET_POINT_TEMPERATURE: Final = "setpointTemperature"
-TEMPERATURE: Final = "temperature"
-HUMIDITY: Final = "humidity"
-LUMINANCE: Final = "luminance"
-IS_REACHABLE: Final = "isReachable"
-IS_OPEN: Final = "isOpen"
-LOCATION: Final = "location"
-
-KEY_INDEX: Final = "index"
-KEY_PRESS_TYPE: Final = "type"
-KEY_PRESS_SHORT: Final = "ShortPress"
-KEY_PRESS_LONG: Final = "LongPress"
-
-
-CAPABILITY_MAP: Final = "capabilityMap"
-CAPABILITY_CONFIG: Final = "capabilityConfig"
-
-EVENT_STATE_CHANGED = "StateChanged"
-EVENT_BUTTON_PRESSED = "ButtonPressed"
-EVENT_MOTION_DETECTED = "MotionDetected"
-
-AUTHENTICATION_HEADERS: Final = {
-    "Authorization": "Basic Y2xpZW50SWQ6Y2xpZW50UGFzcw==",
-    "Content-type": "application/json",
-    "Accept": "application/json",
-}