livisi 0.0.1__py3-none-any.whl → 0.0.19__py3-none-any.whl

livisi/__init__.py

@@ -1,93 +1,4 @@
-# __init__.py
-
-# Import key classes, constants, and exceptions
-
-# livisi_connector.py
-from .livisi_connector import LivisiConnection, connect
-
-# livisi_controller.py
-from .livisi_controller import LivisiController
-
-# livisi_device.py
-from .livisi_device import LivisiDevice
-
-# livisi_websocket.py
-from .livisi_websocket import LivisiWebsocket
-
-# livisi_websocket_event.py
-from .livisi_websocket_event import LivisiWebsocketEvent
-
-# livisi_const.py
-from .livisi_const import (
-    LOGGER,
-    V2_NAME,
-    V1_NAME,
-    V2_WEBSOCKET_PORT,
-    CLASSIC_WEBSOCKET_PORT,
-    WEBSERVICE_PORT,
-    REQUEST_TIMEOUT,
-    CONTROLLER_DEVICE_TYPES,
-    BATTERY_LOW,
-    UPDATE_AVAILABLE,
-    LIVISI_EVENT_STATE_CHANGED,
-    LIVISI_EVENT_BUTTON_PRESSED,
-    LIVISI_EVENT_MOTION_DETECTED,
-    IS_REACHABLE,
-    EVENT_BUTTON_PRESSED,
-    EVENT_BUTTON_LONG_PRESSED,
-    EVENT_MOTION_DETECTED,
-    COMMAND_RESTART,
-)
-
-# livisi_errors.py
-from .livisi_errors import (
-    LivisiException,
-    ShcUnreachableException,
-    WrongCredentialException,
-    IncorrectIpAddressException,
-    TokenExpiredException,
-    ErrorCodeException,
-    ERROR_CODES,
-)
-
-# Define __all__ to specify what is exported when using 'from livisi import *'
-__all__ = [
-    # From livisi_connector.py
-    "LivisiConnection",
-    "connect",
-    # From livisi_controller.py
-    "LivisiController",
-    # From livisi_device.py
-    "LivisiDevice",
-    # From livisi_websocket.py
-    "LivisiWebsocket",
-    # From livisi_websocket_event.py
-    "LivisiWebsocketEvent",
-    # From livisi_const.py
-    "LOGGER",
-    "V2_NAME",
-    "V1_NAME",
-    "V2_WEBSOCKET_PORT",
-    "CLASSIC_WEBSOCKET_PORT",
-    "WEBSERVICE_PORT",
-    "REQUEST_TIMEOUT",
-    "CONTROLLER_DEVICE_TYPES",
-    "BATTERY_LOW",
-    "UPDATE_AVAILABLE",
-    "LIVISI_EVENT_STATE_CHANGED",
-    "LIVISI_EVENT_BUTTON_PRESSED",
-    "LIVISI_EVENT_MOTION_DETECTED",
-    "IS_REACHABLE",
-    "EVENT_BUTTON_PRESSED",
-    "EVENT_BUTTON_LONG_PRESSED",
-    "EVENT_MOTION_DETECTED",
-    "COMMAND_RESTART",
-    # From livisi_errors.py
-    "LivisiException",
-    "ShcUnreachableException",
-    "WrongCredentialException",
-    "IncorrectIpAddressException",
-    "TokenExpiredException",
-    "ErrorCodeException",
-    "ERROR_CODES",
-]
+from .aiolivisi import AioLivisi
+from .websocket import Websocket
+from .errors import IncorrectIpAddressException, WrongCredentialException, ShcUnreachableException, LivisiException
+from .livisi_event import LivisiEvent

livisi/aiolivisi.py

@@ -0,0 +1,270 @@
+"""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

@@ -0,0 +1,40 @@
+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",
+}

livisi/errors.py

@@ -0,0 +1,20 @@
+"""Errors for the Livisi Smart Home component."""
+
+class LivisiException(Exception):
+    """Base class for Livisi exceptions."""
+
+
+class ShcUnreachableException(LivisiException):
+    """Unable to connect to the Smart Home Controller."""
+
+
+class WrongCredentialException(LivisiException):
+    """The user credentials were wrong."""
+
+
+class IncorrectIpAddressException(LivisiException):
+    """The IP address provided by the user is incorrect."""
+
+
+class TokenExpiredException(LivisiException):
+    """The authentication token is expired."""

livisi/livisi_event.py

@@ -0,0 +1,20 @@
+from dataclasses import dataclass
+from pydantic import BaseModel
+from typing import Optional
+
+
+@dataclass(init=False)
+class LivisiEvent(BaseModel):
+    namespace: str
+    properties: Optional[dict]
+    source: str
+    onState: Optional[bool]
+    vrccData: Optional[float]
+    luminance: Optional[int]
+    isReachable: Optional[bool]
+    sequenceNumber: Optional[str]
+    type: Optional[str]
+    timestamp: Optional[str]
+    isOpen: Optional[bool]
+    keyIndex: Optional[int]
+    isLongKeyPress: Optional[bool]

livisi/websocket.py

@@ -0,0 +1,106 @@
+"""Code for communication with the Livisi application websocket."""
+from typing import Callable
+import urllib.parse
+
+import websockets
+from pydantic import ValidationError
+
+from aiolivisi.livisi_event import LivisiEvent
+
+from .aiolivisi import AioLivisi
+from .const import (
+    AVATAR_PORT,
+    IS_REACHABLE,
+    ON_STATE,
+    VALUE,
+    IS_OPEN,
+    SET_POINT_TEMPERATURE,
+    POINT_TEMPERATURE,
+    HUMIDITY,
+    TEMPERATURE,
+    LUMINANCE,
+    KEY_INDEX,
+    KEY_PRESS_LONG,
+    KEY_PRESS_TYPE,
+    EVENT_BUTTON_PRESSED,
+    EVENT_STATE_CHANGED,
+)
+
+
+class Websocket:
+    """Represents the websocket class."""
+
+    def __init__(self, aiolivisi: AioLivisi) -> None:
+        """Initialize the websocket."""
+        self.aiolivisi = aiolivisi
+        self.connection_url: str = None
+
+    async def connect(self, on_data, on_close, port: int) -> None:
+        """Connect to the socket."""
+        if port == AVATAR_PORT:
+            token = urllib.parse.quote(self.aiolivisi.token)
+        else:
+            token = self.aiolivisi.token
+        ip_address = self.aiolivisi.livisi_connection_data["ip_address"]
+        self.connection_url = f"ws://{ip_address}:{port}/events?token={token}"
+        try:
+            async with websockets.connect(
+                self.connection_url, ping_interval=10, ping_timeout=10
+            ) as websocket:
+                try:
+                    self._websocket = websocket
+                    await self.consumer_handler(websocket, on_data)
+                except Exception:
+                    await on_close()
+                    return
+        except Exception:
+            await on_close()
+            return
+
+    async def disconnect(self) -> None:
+        """Close the websocket."""
+        await self._websocket.close(code=1000, reason="Handle disconnect request")
+
+    async def consumer_handler(self, websocket, on_data: Callable):
+        """Used when data is transmited using the websocket."""
+        async for message in websocket:
+            try:
+                event_data = LivisiEvent.parse_raw(message)
+            except ValidationError:
+                continue
+
+            if "device" in event_data.source:
+                event_data.source = event_data.source.replace("/device/", "")
+            if event_data.properties is None:
+                continue
+
+            if event_data.type == EVENT_STATE_CHANGED:
+                if ON_STATE in event_data.properties.keys():
+                    event_data.onState = event_data.properties.get(ON_STATE)
+                elif VALUE in event_data.properties.keys() and isinstance(
+                    event_data.properties.get(VALUE), bool
+                ):
+                    event_data.onState = event_data.properties.get(VALUE)
+                if SET_POINT_TEMPERATURE in event_data.properties.keys():
+                    event_data.vrccData = event_data.properties.get(
+                        SET_POINT_TEMPERATURE
+                    )
+                elif POINT_TEMPERATURE in event_data.properties.keys():
+                    event_data.vrccData = event_data.properties.get(POINT_TEMPERATURE)
+                elif TEMPERATURE in event_data.properties.keys():
+                    event_data.vrccData = event_data.properties.get(TEMPERATURE)
+                elif HUMIDITY in event_data.properties.keys():
+                    event_data.vrccData = event_data.properties.get(HUMIDITY)
+                if LUMINANCE in event_data.properties.keys():
+                    event_data.luminance = event_data.properties.get(LUMINANCE)
+                if IS_REACHABLE in event_data.properties.keys():
+                    event_data.isReachable = event_data.properties.get(IS_REACHABLE)
+                if IS_OPEN in event_data.properties.keys():
+                    event_data.isOpen = event_data.properties.get(IS_OPEN)
+            elif event_data.type == EVENT_BUTTON_PRESSED:
+                if KEY_INDEX in event_data.properties.keys():
+                    event_data.keyIndex = event_data.properties.get(KEY_INDEX)
+                    event_data.isLongKeyPress = (
+                        KEY_PRESS_LONG == event_data.properties.get(KEY_PRESS_TYPE)
+                    )
+            on_data(event_data)