clevertouch 0.4.0__tar.gz → 0.4.2b2__tar.gz

{clevertouch-0.4.0 → clevertouch-0.4.2b2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: clevertouch
-Version: 0.4.0
+Version: 0.4.2b2
 Summary: A Python API for interacting with LVI/Purmo Touch E3-connected radiators
 License: MIT
 Keywords: LVI,home automation,heating

{clevertouch-0.4.0 → clevertouch-0.4.2b2}/pyproject.toml

@@ -13,7 +13,7 @@ log_cli_level = "DEBUG"
 
 [project]
 name = "clevertouch"
-version = "0.4.0"
+version = "0.4.2b2"
 description = "A Python API for interacting with LVI/Purmo Touch E3-connected radiators"
 keywords = [
     "LVI",

clevertouch-0.4.2b2/src/clevertouch/api.py

@@ -0,0 +1,257 @@
+"""Interface to the cloud API."""
+
+from __future__ import annotations
+import logging
+from typing import Optional, NamedTuple, Any
+from hashlib import md5
+from aiohttp import ClientSession, ClientConnectionError, ClientError
+import time
+
+from .util import ApiError
+
+_LOGGER = logging.getLogger(__name__)
+
+
+class ApiStatus(NamedTuple):
+    """Status of an API call."""
+
+    code: int
+    key: str
+    value: str
+
+    def __str__(self) -> str:
+        return f"{self.key}({self.code}): {self.value}"
+
+    def __repr__(self) -> str:
+        return f"code={self.code}, key={self.key}, value={self.value}"
+
+
+class ApiResult(NamedTuple):
+    """Result of an API call."""
+
+    status: ApiStatus
+    data: dict[str, Any]
+    parameters: dict[str, Any]
+
+
+class ApiCallError(ApiError):
+    """Exception raised on errors when calling the cloud API."""
+
+    def __init__(self, status: ApiStatus, *args):
+        super().__init__(*args)
+        self.status: ApiStatus = status
+
+
+class ApiAuthError(ApiError):
+    """Exception raised on authentication errors when calling the cloud API."""
+
+
+class ApiConnectError(ApiError):
+    """Exception raised on connection errors when calling the cloud API."""
+
+
+class ApiSession:
+    """Interface to the cloud API."""
+
+    API_LANG = "en_GB"
+    API_PATH = "/api/v0.1/"
+    CLIENT_ID = "app-front"
+
+    _DEFAULT_HOST = "e3.lvi.eu"
+    _DEFAULT_MANUFACTURER = "purmo"
+
+    def __init__(
+        self,
+        email: Optional[str] = None,
+        refresh_token: Optional[str] = None,
+        *,
+        host: Optional[str] = None,
+        manufacturer: Optional[str] = None,
+    ) -> None:
+        host = host or self._DEFAULT_HOST
+        manufacturer = manufacturer or self._DEFAULT_MANUFACTURER
+        self._token_url = (
+            f"https://auth.{host}/realms/{manufacturer}/protocol/openid-connect/token"
+        )
+        self._api_base = f"https://{host}{self.API_PATH}"
+        self._http_session: ClientSession = ClientSession()
+        self.email: Optional[str] = email
+        self.access_token: Optional[str] = None
+        self.refresh_token: Optional[str] = refresh_token
+        self.expires_at: float = 0.0
+
+    async def __aenter__(self) -> "ApiSession":
+        return self
+
+    async def __aexit__(self, *excinfo) -> None:
+        await self.close()
+
+    async def close(self):
+        """Close the connection to the cloud API."""
+        if self._http_session:
+            await self._http_session.close()
+            self._http_session = None
+
+    async def authenticate(self, email: str, password: str):
+        """Authenticate with the cloud API.
+        On success, sets self.access_token, self.refresh_token, self.expires_at.
+        """
+        self.email = email
+
+        data = {
+            "grant_type": "password",
+            "client_id": self.CLIENT_ID,
+            "username": email,
+            "password": password,
+        }
+
+        try:
+            _LOGGER.debug("Login to openid at '%s' with data '%s'", self._token_url, data)
+            async with self._http_session.post(self._token_url, data=data) as response:
+                if response.status != 200:
+                    _LOGGER.error("OIDC login failed (%s)", response.status)
+                    raise ApiAuthError("Invalid credentials or error fetching token.")
+                token_data = await response.json()
+        except ClientError as exc:
+            raise ApiConnectError(
+                f"Error connecting to {self._token_url}: {exc}"
+            ) from exc
+
+        self.access_token = token_data["access_token"]
+        self.refresh_token = token_data.get("refresh_token")
+        expires_in = token_data.get("expires_in", 3600)  # default 1h
+        self.expires_at = time.time() + expires_in
+
+    async def refresh_openid(self) -> None:
+        """Refresh the existing token using the 'refresh_token' grant."""
+        if not self.refresh_token:
+            raise ApiAuthError("No refresh token stored; cannot refresh.")
+
+        data = {
+            "grant_type": "refresh_token",
+            "client_id": self.CLIENT_ID,
+            "refresh_token": self.refresh_token,
+        }
+        try:
+            async with self._http_session.post(self._token_url, data=data) as response:
+                if response.status != 200:
+                    _LOGGER.error("OIDC refresh failed (%s)", response.status)
+                    raise ApiAuthError("Refresh token invalid or expired.")
+                token_data = await response.json()
+        except ClientError as exc:
+            raise ApiConnectError(
+                f"Error connecting to {self._token_url}: {exc}"
+            ) from exc
+
+        self.access_token = token_data["access_token"]
+        self.refresh_token = token_data.get("refresh_token")
+        expires_in = token_data.get("expires_in", 3600)
+        self.expires_at = time.time() + expires_in
+
+    async def _ensure_valid_token(self) -> None:
+        """Refresh if our token is expired (simple check)."""
+        if time.time() >= self.expires_at:
+            await self.refresh_openid()
+
+    async def _read(
+        self,
+        endpoint: str,
+        payload: dict,
+        *,
+        throw_on_error: bool = True,
+    ) -> ApiResult:
+        result = await self._post(endpoint, payload)
+        if throw_on_error:
+            if result.status.code not in [1, 8]:
+                raise ApiCallError(result.status, f"Read failed with {result.status}")
+        return result
+
+    async def _write(
+        self,
+        endpoint: str,
+        payload: dict,
+        *,
+        throw_on_error: bool = True,
+    ) -> ApiResult:
+        result = await self._post(endpoint, payload)
+        if throw_on_error:
+            if result.status.code != 8:
+                raise ApiCallError(result.status, f"Write failed with {result.status}")
+        return result
+
+    async def read_user_data(self) -> dict[str, Any]:
+        """Read account user data from the cloud API."""
+        endpoint = "human/user/read/"
+        payload = {
+            "email": self.email,
+        }
+        result = await self._read(endpoint, payload)
+        return result.data
+
+    async def read_home_data(self, home_id: str) -> dict[str, Any]:
+        """Read home data from the cloud API."""
+        endpoint = "human/smarthome/read/"
+        payload = {
+            "smarthome_id": home_id,
+        }
+        result = await self._read(endpoint, payload)
+        return result.data
+
+    async def write_query(self, home_id: str, query_params: dict[str, Any]):
+        """Write an update query to the cloud API."""
+        endpoint = "human/query/push/"
+        payload = {
+            "smarthome_id": home_id,
+            "context": 1,
+            "peremption": 15000,
+        }
+        for key, value in query_params.items():
+            payload[f"query[{key}]"] = value
+
+        return await self._write(endpoint, payload)
+
+    def _parse_api_json(self, json: dict) -> ApiResult:
+        try:
+            code = json["code"]
+            data = json["data"]
+            parameters = json.get("parameters")
+        except Exception as ex:
+            raise ApiError("Unexpected JSON format in API response") from ex
+
+        try:
+            code_num = int(code["code"])
+            code_key = code["key"]
+            code_value = code["value"]
+            status = ApiStatus(code_num, code_key, code_value)
+        except Exception as ex:
+            raise ApiError("API status is malformed") from ex
+
+        return ApiResult(status, data, parameters)
+
+    async def _post(self, endpoint: str, payload: dict | None = None) -> dict:
+        """Make an authenticated API request"""
+        await self._ensure_valid_token()
+        headers = {
+            "Authorization": f"Bearer {self.access_token}",
+        }
+
+        url = f"{self._api_base}{endpoint.lstrip('/')}"
+
+        try:
+            async with self._http_session.post(
+                url, data=payload or {}, headers=headers
+            ) as resp:
+                resp.raise_for_status()
+                json_data = await resp.json()
+        except ClientError as exc:
+            _LOGGER.exception("API request failed: %s", exc)
+            raise ApiConnectError(f"API request failed: {exc}") from exc
+
+        try:
+            result = self._parse_api_json(json_data)
+            _LOGGER.debug("%s called with status %s", endpoint, result)
+        except Exception as ex:
+            _LOGGER.exception("Could not parse JSON result from API request")
+            result = None
+
+        return result

{clevertouch-0.4.0 → clevertouch-0.4.2b2}/src/clevertouch/devices/radiator.py

@@ -147,25 +147,18 @@ class Radiator(Device):
         )
         # Read boost settings
         # 'boost_time' is the user writable boost time
-        try:
-            self.boost_time = int(data["time_boost"])
-        except KeyError:  # The key doesn't exist
-            self.boost_time = 0
-        except ValueError:  # The value can not be converted to an int
-            self.boost_time = 0
+        self.boost_time = int(data.get("time_boost") or 0)
         # 'time_boost_format_chrono' holds remaining boost time with higher resolution
-        try:
-            node = data["time_boost_format_chrono"]
+        node = data.get("time_boost_format_chrono")
+        if node:
             self.boost_remaining = (
-                int(node["d"]) * 24 * 60 * 60
-                + int(node["h"]) * 60 * 60
-                + int(node["m"]) * 60
-                + int(node["s"])
+                int(node.get("d") or 0) * 24 * 60 * 60
+                + int(node.get("h") or 0) * 60 * 60
+                + int(node.get("m") or 0) * 60
+                + int(node.get("s") or 0)
             )
-        except KeyError:
-            self.boost_remaining = 0
-        except ValueError:
-            self.boost_remaining = 0
+        else:
+            self.boost_remaining = None
 
     async def set_temperature(self, temp_type: str, temp_value: float, unit: str):
         """Set a specific temperature for a radiator"""
@@ -252,8 +245,8 @@ class Radiator(Device):
 
         if heat_mode not in self._HEAT_MODE_TO_DEVICE:
             raise ApiError(f"Heating mode {heat_mode} not available.")
-        if (temp_value or temp_unit) and (not temp_value or not temp_unit):
-            raise ApiError("Both temp value and unit must be set.")
+        if temp_value and not temp_unit:
+            raise ApiError("Unit must be set when a temp value is provided.")
         if temp_value and heat_mode not in self._HEAT_MODE_TO_WRITABLE_TEMP_TYPE:
             raise ApiError(f"Temperature can not be set for {heat_mode}.")
         if boost_time and heat_mode != HeatMode.BOOST:
@@ -264,7 +257,7 @@ class Radiator(Device):
         query_params["gv_mode"] = self._HEAT_MODE_TO_DEVICE[heat_mode]
         query_params["nv_mode"] = self._HEAT_MODE_TO_DEVICE[heat_mode]
 
-        if temp_value:
+        if temp_value and temp_unit:
             temp_type = self._HEAT_MODE_TO_WRITABLE_TEMP_TYPE[heat_mode]
             new_temp = Temperature(
                 temp_value, temp_unit, is_writable=True, name=temp_type

{clevertouch-0.4.0 → clevertouch-0.4.2b2}/src/clevertouch/info.py

@@ -26,7 +26,7 @@ class HomeInfo:
             self.zones = {
                 zone.id_local: zone
                 for zone in [
-                    ZoneInfo(zone_data) for zone_data in data["zones"].values()
+                    ZoneInfo(zone_data) for zone_data in data["zones"]
                 ]
             }
         else:

{clevertouch-0.4.0 → clevertouch-0.4.2b2}/src/clevertouch/objects.py

@@ -37,11 +37,10 @@ class Account:
     async def authenticate(
         self,
         email: str,
-        password: Optional[str] = None,
-        password_hash: Optional[str] = None,
+        password: Optional[str] = None
     ) -> None:
         """Authenticate with the cloud API and store credentials."""
-        await self._api_session.authenticate(email, password, password_hash)
+        await self._api_session.authenticate(email, password)
         self.email = self._api_session.email
 
     async def get_user(self) -> User:
@@ -91,7 +90,7 @@ class Home:
     def _update(self, data):
         self.info.update(data)
 
-        for device_data in data["devices"].values():
+        for device_data in data["devices"]:
             device_id = Device.get_id(device_data)
             device = self.devices.get(device_id)
             if device is None:
@@ -126,6 +125,6 @@ class User:
         self.homes = {
             home.home_id: home
             for home in [
-                HomeInfo(data=home_data) for home_data in data["smarthomes"].values()
+                HomeInfo(data=home_data) for home_data in data["smarthomes"]
             ]
         }

clevertouch-0.4.0/src/clevertouch/api.py

@@ -1,223 +0,0 @@
-"""Interface to the cloud API."""
-from __future__ import annotations
-import logging
-from typing import Optional, NamedTuple, Any
-from hashlib import md5
-from aiohttp import ClientSession, ClientConnectionError, ClientError
-
-from .util import ApiError
-
-_LOGGER = logging.getLogger(__name__)
-
-
-class ApiStatus(NamedTuple):
-    """Status of an API call."""
-
-    code: int
-    key: str
-    value: str
-
-    def __str__(self) -> str:
-        return f"{self.key}({self.code}): {self.value}"
-
-    def __repr__(self) -> str:
-        return f"code={self.code}, key={self.key}, value={self.value}"
-
-
-class ApiResult(NamedTuple):
-    """Result of an API call."""
-
-    status: ApiStatus
-    data: dict[str, Any]
-    parameters: dict[str, Any]
-
-
-class ApiCallError(ApiError):
-    """Exception raised on errors when calling the cloud API."""
-
-    def __init__(self, status: ApiStatus, *args):
-        super().__init__(*args)
-        self.status: ApiStatus = status
-
-
-class ApiAuthError(ApiError):
-    """Exception raised on authentication errors when calling the cloud API."""
-
-
-class ApiConnectError(ApiError):
-    """Exception raised on connection errors when calling the cloud API."""
-
-
-class ApiSession:
-    """Interface to the cloud API."""
-
-    API_LANG = "en_GB"
-    _LVI_API_BASE = "https://e3.lvi.eu"
-    API_PATH = "/api/v0.1/"
-
-    def __init__(
-        self,
-        email: Optional[str] = None,
-        token: Optional[str] = None,
-        *,
-        host: Optional[str] = None
-    ) -> None:
-        api_base = host or self._LVI_API_BASE
-        self._http_session: ClientSession = ClientSession(api_base)
-        self.email: Optional[str] = email
-        self.token: Optional[str] = token
-
-    async def __aenter__(self):
-        return self
-
-    async def __aexit__(self, *excinfo):
-        await self.close()
-
-    async def close(self):
-        """Close the connection to the cloud API."""
-        await self._http_session.close()
-
-    async def authenticate(
-        self,
-        email: str,
-        password: Optional[str] = None,
-        password_hash: Optional[str] = None,
-    ):
-        """Authenticate with the cloud API."""
-        self.email = email
-        if password_hash is None or password_hash == "":
-            if password is None:
-                raise ApiError("No password provided")
-            password_hash = md5(password.encode()).hexdigest()
-
-        endpoint = "human/user/auth/"
-        payload = {
-            "email": email,
-            "password": password_hash,
-            "remember_me": "true",
-            "lang": self.API_LANG,
-        }
-
-        result = await self._post(endpoint, payload, authenticate=False)
-
-        status = result.status
-        if status.key != "OK":
-            if status.key == "ERR_ROUTE":
-                raise ApiConnectError(status)
-            if status.key == "ERR_PARAM":
-                raise ApiAuthError("Invalid email or password")
-            raise ApiCallError(status, "Authentication failed %s", status)
-
-        self.email = result.data["user_infos"]["email"]
-        self.token = result.data["token"]
-
-    async def _read(
-        self,
-        endpoint: str,
-        payload: dict,
-        *,
-        authenticate: bool = True,
-        throw_on_error: bool = True,
-    ) -> ApiResult:
-        result = await self._post(endpoint, payload, authenticate=authenticate)
-        if throw_on_error:
-            if result.status.code != 1:
-                raise ApiCallError(result.status, f"Read failed with {result.status}")
-        return result
-
-    async def _write(
-        self,
-        endpoint: str,
-        payload: dict,
-        *,
-        authenticate: bool = True,
-        throw_on_error: bool = True,
-    ) -> ApiResult:
-        result = await self._post(endpoint, payload, authenticate=authenticate)
-        if throw_on_error:
-            if result.status.code != 8:
-                raise ApiCallError(result.status, f"Write failed with {result.status}")
-        return result
-
-    async def read_user_data(self) -> dict[str, Any]:
-        """Read account user data from the cloud API."""
-        endpoint = "human/user/read/"
-        payload = {
-            "email": self.email,
-        }
-        result = await self._read(endpoint, payload)
-        return result.data
-
-    async def read_home_data(self, home_id: str) -> dict[str, Any]:
-        """Read home data from the cloud API."""
-        endpoint = "human/smarthome/read/"
-        payload = {
-            "smarthome_id": home_id,
-        }
-        result = await self._read(endpoint, payload)
-        return result.data
-
-    async def write_query(self, home_id: str, query_params: dict[str, Any]):
-        """Write an update query to the cloud API."""
-        endpoint = "human/query/push/"
-        payload = {
-            "smarthome_id": home_id,
-            "context": 1,
-            "peremption": 15000,
-        }
-        for key, value in query_params.items():
-            payload[f"query[{key}]"] = value
-
-        return await self._write(endpoint, payload)
-
-    def _parse_api_json(self, json: dict) -> ApiResult:
-        try:
-            code = json["code"]
-            data = json["data"]
-            parameters = json["parameters"]
-        except Exception as ex:
-            raise ApiError("Unexpected JSON format in API response") from ex
-
-        try:
-            code_num = int(code["code"])
-            code_key = code["key"]
-            code_value = code["value"]
-            status = ApiStatus(code_num, code_key, code_value)
-        except Exception as ex:
-            raise ApiError("API status is malformed") from ex
-
-        return ApiResult(status, data, parameters)
-
-    async def _post(
-        self, endpoint: str, payload: dict[str, Any], *, authenticate: bool
-    ) -> ApiResult:
-        if authenticate:
-            payload.update(
-                {
-                    "token": self.token,
-                    "lang": self.API_LANG,
-                }
-            )
-
-        try:
-            async with self._http_session.post(
-                self.API_PATH + endpoint, data=payload
-            ) as response:
-                response.raise_for_status()
-                json_data = await response.json()
-        except ClientConnectionError as ex:
-            raise ApiConnectError(f"Connection error - {ex}") from ex
-        except ClientError as ex:
-            raise ApiConnectError(f"Unexpected cloud API error - {ex}") from ex
-
-        result = self._parse_api_json(json_data)
-
-        _LOGGER.debug(
-            "%s called with status %s (%s): %s",
-            endpoint,
-            result.status.key,
-            result.status.code,
-            result.status.value,
-        )
-
-        return result

clevertouch-0.4.0/tests/.pytest_cache/.gitignore

@@ -1,2 +0,0 @@
-# Created by pytest automatically.
-*

clevertouch-0.4.0/tests/.pytest_cache/CACHEDIR.TAG

@@ -1,4 +0,0 @@
-Signature: 8a477f597d28d172789f06886806bc55
-# This file is a cache directory tag created by pytest.
-# For information about cache directory tags, see:
-#	https://bford.info/cachedir/spec.html

clevertouch-0.4.0/tests/.pytest_cache/README.md

@@ -1,8 +0,0 @@
-# pytest cache directory #
-
-This directory contains data from the pytest's cache plugin,
-which provides the `--lf` and `--ff` options, as well as the `cache` fixture.
-
-**Do not** commit this to version control.
-
-See [the docs](https://docs.pytest.org/en/stable/how-to/cache.html) for more information.

clevertouch-0.4.0/tests/.pytest_cache/v/cache/lastfailed

@@ -1,4 +0,0 @@
-{
-  "authenticate.py::test_authentication": true,
-  "authenticate_test.py::test_authentication": true
-}

clevertouch-0.4.0/tests/.pytest_cache/v/cache/nodeids

@@ -1,5 +0,0 @@
-[
-  "authenticate.py::test_authentication",
-  "authenticate_test.py::test_authentication",
-  "authenticate_test.py::test_true"
-]

clevertouch-0.4.0/tests/.pytest_cache/v/cache/stepwise

@@ -1 +0,0 @@
-[]