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

livisi/__init__.py

@@ -45,7 +45,6 @@ from .livisi_errors import (
     ShcUnreachableException,
     WrongCredentialException,
     IncorrectIpAddressException,
-    TokenExpiredException,
     ErrorCodeException,
     ERROR_CODES,
 )
@@ -87,7 +86,6 @@ __all__ = [
     "ShcUnreachableException",
     "WrongCredentialException",
     "IncorrectIpAddressException",
-    "TokenExpiredException",
     "ErrorCodeException",
     "ERROR_CODES",
 ]

livisi/livisi_connector.py

@@ -3,11 +3,15 @@
 from __future__ import annotations
 
 import asyncio
+import time
+import base64
+
 from contextlib import suppress
 
 from typing import Any
 import uuid
 import json
+
 from aiohttp import ClientResponseError, ServerDisconnectedError, ClientConnectorError
 from aiohttp.client import ClientSession, ClientError, TCPConnector
 from dateutil.parser import parse as parse_timestamp
@@ -60,6 +64,90 @@ class LivisiConnection:
 
         self._web_session = None
         self._websocket = LivisiWebsocket(self)
+        self._token_refresh_lock = asyncio.Lock()
+
+    def _decode_jwt_payload(self, token: str) -> dict | None:
+        """Decode JWT payload and return payload dict or None on error."""
+        if not token:
+            return None
+
+        try:
+            # JWT tokens have 3 parts separated by dots: header.payload.signature
+            parts = token.split(".")
+            if len(parts) != 3:
+                return None
+
+            # Decode the payload (second part)
+            payload = parts[1]
+
+            # Add padding if needed (JWT base64 encoding might not have padding)
+            padding = 4 - (len(payload) % 4)
+            if padding != 4:
+                payload += "=" * padding
+
+            try:
+                decoded_bytes = base64.urlsafe_b64decode(payload)
+                payload_json = json.loads(decoded_bytes.decode("utf-8"))
+                return payload_json
+
+            except (json.JSONDecodeError, UnicodeDecodeError):
+                return None
+
+        except Exception:
+            return None
+
+    def _format_token_info(self, token: str) -> str:
+        """Format token information for logging."""
+        payload = self._decode_jwt_payload(token)
+        if not payload:
+            return "None" if not token else f"Invalid JWT (length: {len(token)})"
+
+        info_parts = []
+
+        # User/subject
+        if "sub" in payload:
+            info_parts.append(f"user: {payload['sub']}")
+        elif "username" in payload:
+            info_parts.append(f"user: {payload['username']}")
+
+        # Expiration time
+        if "exp" in payload:
+            exp_time = payload["exp"]
+            current_time = time.time()
+            if exp_time > current_time:
+                time_left = exp_time - current_time
+                if time_left > 3600:
+                    info_parts.append(f"expires in: {time_left/3600:.1f}h")
+                elif time_left > 60:
+                    info_parts.append(f"expires in: {time_left/60:.1f}m")
+                else:
+                    info_parts.append(f"expires in: {time_left:.0f}s")
+            else:
+                info_parts.append("expired")
+
+        # Issue time (age)
+        if "iat" in payload:
+            iat_time = payload["iat"]
+            age = time.time() - iat_time
+            if age > 3600:
+                info_parts.append(f"age: {age/3600:.1f}h")
+            elif age > 60:
+                info_parts.append(f"age: {age/60:.1f}m")
+            else:
+                info_parts.append(f"age: {age:.0f}s")
+
+        # Token ID if available
+        if "jti" in payload:
+            jti = payload["jti"]
+            if len(jti) > 8:
+                info_parts.append(f"id: {jti[:8]}...")
+            else:
+                info_parts.append(f"id: {jti}")
+
+        if info_parts:
+            return f"JWT({', '.join(info_parts)})"
+        else:
+            return f"JWT({len(payload)} claims)"
 
     async def connect(self, host: str, password: str):
         """Connect to the livisi SHC and retrieve controller information."""
@@ -75,6 +163,8 @@ class LivisiConnection:
             await self.close()
             raise
 
+        self._connect_time = time.time()
+
         self.controller = await self._async_get_controller()
         if self.controller.is_v2:
             # reconnect with more concurrent connections on v2 SHC
@@ -124,9 +214,13 @@ class LivisiConnection:
         return web_session
 
     async def _async_retrieve_token(self) -> None:
-        """Set the JWT from the LIVISI Smart Home Controller."""
+        """Set the token from the LIVISI Smart Home Controller."""
         access_data: dict = {}
 
+        # Ensure token is cleared before attempting to fetch a new one
+        # so that future requests will reauthenticate on failure
+        self.token = None
+
         if self._password is None:
             raise LivisiException("No password set")
 
@@ -150,47 +244,130 @@ class LivisiConnection:
                 headers=headers,
             )
             LOGGER.debug("Updated access token")
-            self.token = access_data.get("access_token")
+            new_token = access_data.get("access_token")
+            LOGGER.info(
+                "Received token from SHC: %s", self._format_token_info(new_token)
+            )
+            self.token = new_token
             if self.token is None:
                 errorcode = access_data.get("errorcode")
                 errordesc = access_data.get("description", "Unknown Error")
                 if errorcode in (2003, 2009):
+                    LOGGER.debug("Invalid credentials for SHC")
                     raise WrongCredentialException
                 # log full response for debugging
                 LOGGER.error("SHC response does not contain access token")
                 LOGGER.error(access_data)
                 raise LivisiException(f"No token received from SHC: {errordesc}")
+            self._connect_time = time.time()
         except ClientError as error:
+            LOGGER.debug("Error connecting to SHC: %s", error)
             if len(access_data) == 0:
                 raise IncorrectIpAddressException from error
             raise ShcUnreachableException from error
+        except TimeoutError as error:
+            LOGGER.debug("Timeout waiting for SHC")
+            raise ShcUnreachableException("Timeout waiting for shc") from error
+        except ClientResponseError as error:
+            LOGGER.debug("SHC response: %s", error.message)
+            if error.status == 401:
+                raise WrongCredentialException from error
+            raise LivisiException(
+                f"Invalid response from SHC, response code {error.status} ({error.message})"
+            ) from error
+        except Exception as error:
+            LOGGER.debug("Error retrieving token from SHC: %s", error)
+            raise LivisiException("Error retrieving token from SHC") from error
+
+    async def _async_refresh_token(self) -> None:
+        """Refresh the token if needed, using a lock to prevent concurrent refreshes."""
+
+        # remember the token that was expired, so we can check if it was already refreshed by another request
+        expired_token = self.token
+
+        async with self._token_refresh_lock:
+            # Check if token needs to be refreshed
+            if self.token is None or self.token == expired_token:
+                LOGGER.info(
+                    "Livisi token %s is missing or expired, requesting new token from SHC",
+                    self._format_token_info(self.token),
+                )
+                try:
+                    await self._async_retrieve_token()
+                except Exception as e:
+                    LOGGER.error("Unhandled error requesting token", exc_info=e)
+                    raise
+            else:
+                # Token was already refreshed by another request during the lock
+                LOGGER.debug(
+                    "Token already refreshed by another request, using new token %s",
+                    self._format_token_info(self.token),
+                )
 
     async def _async_request(
         self, method, url: str, payload=None, headers=None
     ) -> dict:
         """Send a request to the Livisi Smart Home controller and handle requesting new token."""
+
+        # Check if the token is expired (not sure if this works on V1 SHC, so keep the old 2007 refresh code below too)
+        token_payload = self._decode_jwt_payload(self.token)
+        if token_payload:
+            expires = token_payload.get("exp", 0)
+            if expires > 0 and time.time() >= expires:
+                LOGGER.debug(
+                    "Livisi token %s detected as expired",
+                    self._format_token_info(self.token),
+                )
+                # Token is expired, we need to refresh it
+                try:
+                    await self._async_refresh_token()
+                except Exception as e:
+                    LOGGER.error("Unhandled error refreshing token", exc_info=e)
+                    raise
+
+        # now send the request
         response = await self._async_send_request(method, url, payload, headers)
 
         if response is not None and "errorcode" in response:
             errorcode = response.get("errorcode")
-            # reconnect on expired token
+            # Handle expired token (2007)
             if errorcode == 2007:
-                await self._async_retrieve_token()
-                response = await self._async_send_request(method, url, payload, headers)
+                LOGGER.debug(
+                    "Livisi token %s expired (error 2007)",
+                    self._format_token_info(self.token),
+                )
+                await self._async_refresh_token()
+
+                # Retry the original request with the (possibly new) token
+                try:
+                    response = await self._async_send_request(
+                        method, url, payload, headers
+                    )
+                except Exception as e:
+                    LOGGER.error(
+                        "Unhandled error re-sending request after token update",
+                        exc_info=e,
+                    )
+                    raise
+
+                # Check if the retry also failed
                 if response is not None and "errorcode" in response:
+                    retry_errorcode = response.get("errorcode")
                     LOGGER.error(
-                        "Livisi sent error code %d after token request",
-                        response.get("errorcode"),
+                        "Livisi sent error code %d after token refresh", retry_errorcode
                     )
-                    raise ErrorCodeException(response["errorcode"])
+                    raise ErrorCodeException(retry_errorcode)
+
+                return response
             else:
+                # Handle other error codes
                 LOGGER.error(
                     "Error code %d (%s) on url %s",
                     errorcode,
                     ERROR_CODES.get(errorcode, "unknown"),
                     url,
                 )
-                raise ErrorCodeException(response["errorcode"])
+                raise ErrorCodeException(errorcode)
 
         return response
 
@@ -267,7 +444,7 @@ class LivisiConnection:
             ("device", "capability", "location"),
         ):
             if isinstance(result, Exception):
-                LOGGER.warn(f"Error loading {path}")
+                LOGGER.warning(f"Error loading {path}")
                 raise result  # Re-raise the exception immediately
 
         controller_id = next(
@@ -391,18 +568,22 @@ class LivisiConnection:
             return None
 
         requestUrl = f"capability/{capability}/state"
+
         try:
             response = await self.async_send_authorized_request("get", requestUrl)
-            if response is None:
-                return None
-            if not isinstance(response, dict):
-                return None
-            return response.get(property, None)
-        except Exception:
-            LOGGER.warning(
-                f"Error getting device state (url: {requestUrl})", exc_info=True
+        except Exception as e:
+            # just debug log the exception but let the caller handle it
+            LOGGER.debug(
+                "Unhandled error requesting device value",
+                exc_info=e,
             )
+            raise
+
+        if response is None:
+            return None
+        if not isinstance(response, dict):
             return None
+        return response.get(property, None)
 
     async def async_set_state(
         self,

livisi/livisi_websocket.py

@@ -1,5 +1,6 @@
 """Code for communication with the Livisi application websocket."""
 
+import asyncio
 from collections.abc import Callable
 import urllib.parse
 
@@ -7,7 +8,14 @@ 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_const import (
+    CLASSIC_WEBSOCKET_PORT,
+    LIVISI_EVENT_BUTTON_PRESSED,
+    LIVISI_EVENT_MOTION_DETECTED,
+    LIVISI_EVENT_STATE_CHANGED,
+    V2_WEBSOCKET_PORT,
+    LOGGER,
+)
 from .livisi_websocket_event import LivisiWebsocketEvent
 
 
@@ -36,21 +44,20 @@ class LivisiWebsocket:
         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:
+        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)
                 self._websocket = None
+        except Exception as e:
+            self._websocket = None
+            LOGGER.exception("Error handling websocket connection", exc_info=e)
+        if not self._disconnecting:
+            LOGGER.warning("WebSocket disconnected unexpectedly.")
+        await on_close()
 
     async def disconnect(self) -> None:
         """Close the websocket."""
@@ -74,13 +81,28 @@ class LivisiWebsocket:
                     continue
 
                 if event_data.properties is None or event_data.properties == {}:
-                    LOGGER.warning("Received event with no properties, skipping.")
+                    LOGGER.debug("Received event with no properties, skipping.")
+                    LOGGER.debug("Event data: %s", event_data)
+                    if event_data.type not in [
+                        LIVISI_EVENT_STATE_CHANGED,
+                        LIVISI_EVENT_BUTTON_PRESSED,
+                        LIVISI_EVENT_MOTION_DETECTED,
+                    ]:
+                        LOGGER.info(
+                            "Received %s event from Livisi websocket", event_data.type
+                        )
                     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)
+                try:
+                    on_data(event_data)
+                except Exception as e:
+                    LOGGER.error("Unhandled error in on_data", exc_info=e)
+
+        except asyncio.exceptions.CancelledError:
+            LOGGER.warning("Livisi WebSocket consumer handler stopped")
         except Exception as e:
             LOGGER.error("Unhandled error in WebSocket consumer handler", exc_info=e)

{livisi-0.9.0.dist-info → livisi-1.0.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
-Metadata-Version: 2.2
+Metadata-Version: 2.4
 Name: livisi
-Version: 0.9.0
+Version: 1.0.0
 Summary: Connection library for the abandoned Livisi Smart Home system
 Author-email: Felix Rotthowe <felix@planbnet.org>
 License: Apache-2.0
@@ -15,6 +15,7 @@ License-File: LICENSE
 Requires-Dist: colorlog>=6.8.2
 Requires-Dist: aiohttp>=3.8.5
 Requires-Dist: websockets>=11.0.3
+Dynamic: license-file
 
 # livisi
 

livisi-1.0.0.dist-info/RECORD

@@ -0,0 +1,15 @@
+livisi/__init__.py,sha256=16tPoT93D3md0qHQ40sb5hX-gdzVtjGV0jh0PFzSkuU,2169
+livisi/livisi_connector.py,sha256=UavIT5Vzu14htoXgI5Ipm4tNyFMroL9ejLigIpMNBtM,24957
+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=4AO8oLR845F_Lzcn7vFtDQv_KKmh4hxLEQuEh63ikqQ,4198
+livisi/livisi_websocket_event.py,sha256=pbjyiKid9gOWMcWiw5jq0dbo2DQ7dAQnxM0D_UJBltw,273
+livisi-1.0.0.dist-info/licenses/LICENSE,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+livisi-1.0.0.dist-info/METADATA,sha256=J-wtmNvcEIylifeMgitRIndIMNPk3h1vHYgzxJlhjf8,1285
+livisi-1.0.0.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+livisi-1.0.0.dist-info/top_level.txt,sha256=ctiU5MMpBSwoQR7mJWIuyB1ND1_g004Xa3vNmMsSiCs,7
+livisi-1.0.0.dist-info/RECORD,,

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

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

livisi-0.9.0.dist-info/RECORD

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