smartbox 2.4.0__tar.gz → 2.5.0__tar.gz

{smartbox-2.4.0 → smartbox-2.5.0}/.github/workflows/publish-to-pypi.yml

@@ -5,7 +5,7 @@ on:
     tags:
       - "v*"
 env:
-  PYTHON_VERSION: 3.13
+  PYTHON_VERSION: 3.14
 
 jobs:
   build-n-publish:
@@ -22,7 +22,7 @@ jobs:
         with:
           python-version: ${{ env.PYTHON_VERSION }}
       - name: Set up Python ${{ env.PYTHON_VERSION }}
-        uses: actions/setup-python@v6.1.0
+        uses: actions/setup-python@v6.2.0
         with:
           python-version: ${{ env.PYTHON_VERSION }}
       - name: Build a binary wheel and a source tarball

{smartbox-2.4.0 → smartbox-2.5.0}/.github/workflows/python-package.yml

@@ -16,7 +16,7 @@ jobs:
     strategy:
       max-parallel: 4
       matrix:
-        python-version: [3.13, 3.14]
+        python-version: [3.14]
     steps:
       - uses: actions/checkout@v6
       - name: Install uv
@@ -24,7 +24,7 @@ jobs:
         with:
           python-version: ${{ matrix.python-version }}
       - name: Set up Python ${{ matrix.python-version }}
-        uses: actions/setup-python@v6.1.0
+        uses: actions/setup-python@v6.2.0
         with:
           python-version: ${{ matrix.python-version }}
       - name: Install the project
@@ -37,7 +37,7 @@ jobs:
     strategy:
       max-parallel: 1
       matrix:
-        python-version: [3.13, 3.14]
+        python-version: [3.14]
 
     steps:
       - uses: actions/checkout@v6
@@ -46,7 +46,7 @@ jobs:
         with:
           python-version: ${{ matrix.python-version }}
       - name: Set up Python ${{ matrix.python-version }}
-        uses: actions/setup-python@v6.1.0
+        uses: actions/setup-python@v6.2.0
         with:
           python-version: ${{ matrix.python-version }}
       - name: Install the project
@@ -59,7 +59,7 @@ jobs:
     strategy:
       max-parallel: 4
       matrix:
-        python-version: [3.13, 3.14]
+        python-version: [3.14]
 
     steps:
       - uses: actions/checkout@v6
@@ -69,7 +69,7 @@ jobs:
           python-version: ${{ matrix.python-version }}
 
       - name: Set up Python ${{ matrix.python-version }}
-        uses: actions/setup-python@v6.1.0
+        uses: actions/setup-python@v6.2.0
         with:
           python-version: ${{ matrix.python-version }}
       - name: Install the project

{smartbox-2.4.0 → smartbox-2.5.0}/.gitignore

@@ -30,6 +30,7 @@ share/python-wheels/
 .installed.cfg
 *.egg
 MANIFEST
+.sonar/
 
 # PyInstaller
 #  Usually these files are written by a python script from a template

{smartbox-2.4.0 → smartbox-2.5.0}/.pre-commit-config.yaml

@@ -2,7 +2,7 @@ repos:
 
 - repo: https://github.com/astral-sh/uv-pre-commit
   # uv version.
-  rev: 0.9.25
+  rev: 0.10.8
   hooks:
     # Update the uv lockfile
     - id: uv-lock
@@ -22,7 +22,7 @@ repos:
       - "--indent=4"
 
 - repo: https://github.com/astral-sh/ruff-pre-commit
-  rev: v0.14.11
+  rev: v0.15.4
   hooks:
     - id: ruff
       args: [--fix, --exit-non-zero-on-fix]

{smartbox-2.4.0 → smartbox-2.5.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: smartbox
-Version: 2.4.0
+Version: 2.5.0
 Summary: Python API to control heating 'smart boxes'
 Project-URL: Homepage, https://github.com/ajtudela/smartbox
 Project-URL: Issues, https://github.com/ajtudela/smartbox/issues
@@ -10,7 +10,7 @@ License-File: LICENSE
 Classifier: License :: OSI Approved :: MIT License
 Classifier: Operating System :: OS Independent
 Classifier: Programming Language :: Python :: 3
-Requires-Python: >=3.13
+Requires-Python: >=3.14.2
 Requires-Dist: aiohttp
 Requires-Dist: asyncclick
 Requires-Dist: jq

{smartbox-2.4.0 → smartbox-2.5.0}/pyproject.toml

@@ -1,7 +1,7 @@
 [project]
 name = "smartbox"
-version = "2.4.0"
-requires-python = ">=3.13"
+version = "2.5.0"
+requires-python = ">=3.14.2"
 authors = [
   { name="Alberto Tudela", email="ajtudela@gmail.com" },
   { name="Delmael", email="delmael@outlook.com" },
@@ -136,3 +136,18 @@ max-complexity = 25
 
 [tool.setuptools.packages.find]
 where = ["src"]
+
+[tool.tox]
+env_list = ["3.14"]
+
+[tool.tox.env_run_base]
+isolated_build = true
+description = "Run test under {base_python}"
+dependency_groups = ["dev"]
+commands = [["python", "-m", "pytest", "--cov=smartbox", "--cov-append", "--cov-report=term", "--cov-report=xml", "--junitxml=junit.xml"]]
+
+[tool.sonar]
+"sonar.python.version" = "3.14"
+"python.coverage.reportPaths" = "coverage.xml"
+"sonar.tests" = "tests"
+"python.xunit.reportPath" = "junit.xml"

{smartbox-2.4.0 → smartbox-2.5.0}/src/smartbox/models.py

@@ -83,14 +83,16 @@ class NodeSetup(RootModel[DefaultNodeSetup | PmoSetup]):
         """Get the root model directly."""
         return getattr(self.root, name)
 
+
 class NodeVersion(BaseModel):
     """NodeVersion model."""
-    
+
     hw_version: str
     fw_version: str
     uid: str
     pid: str
 
+
 class DefaultNodeStatus(BaseModel):
     """Default Node Status."""
 
@@ -173,6 +175,7 @@ class Node(BaseModel):
     installed: bool
     lost: bool | None = False
 
+
 class Nodes(BaseModel):
     """Nodes model."""
 

{smartbox-2.4.0 → smartbox-2.5.0}/src/smartbox/session.py

@@ -5,7 +5,7 @@ import datetime
 import json
 import logging
 import time
-from typing import Any
+from typing import Any, Self
 
 import aiohttp
 from aiohttp import ClientSession
@@ -72,6 +72,10 @@ class AsyncSession:
         self._username: str = username
         self._password: str = password
         self._access_token: str = ""
+        self._refresh_token: str = ""
+        self._expires_at: datetime.datetime = datetime.datetime.now(
+            datetime.UTC
+        )
         self._client_session: ClientSession | None = websession
         self.raw_response: bool = raw_response
         self._headers: dict[str, str] = {
@@ -83,6 +87,29 @@ class AsyncSession:
         if self.reseller.web_url:
             self._headers.update({"x-referer": self.reseller.web_url})
 
+    async def __aenter__(self) -> Self:
+        """Async context manager entry."""
+        _LOGGER.debug(
+            "__aenter__ of AsyncSmartboxSession, authenticating and creating client session if not provided",
+        )
+        return self
+
+    async def __aexit__(
+        self,
+        exc_type: type[BaseException] | None,
+        exc_val: BaseException | None,
+        exc_tb: object,
+    ) -> None:
+        """Async context manager exit."""
+        _LOGGER.debug(
+            "Async context manager exit, closing client session and socket if exists"
+        )
+        if self._client_session:
+            await self._client_session.close()
+        # Cleanup socket if exists
+        if hasattr(self, "_socket") and self._socket:
+            await self._socket.disconnect()
+
     @property
     def reseller(self) -> SmartboxReseller:
         """Get the reseller."""
@@ -117,37 +144,39 @@ class AsyncSession:
     def client(self) -> ClientSession:
         """Return the underlying http client."""
         if not self._client_session:
-            return ClientSession()
+            self._client_session = ClientSession()
         return self._client_session
 
     async def health_check(self) -> dict[str, Any]:
         """Check if the API is alived."""
         api_url = f"{self._api_host}/health_check"
         try:
-            response = await self.client.get(api_url)
+            async with self.client.get(api_url) as response:
+                response.raise_for_status()
+                return await response.json()
         except (
             aiohttp.ClientConnectionError,
             aiohttp.ClientConnectorError,
         ) as e:
             raise APIUnavailableError(e) from e
-        return await response.json()
 
     async def api_version(self) -> dict[str, str]:
         """Check if the API is alived."""
         api_url = f"{self._api_host}/version"
         try:
-            response = await self.client.get(api_url)
+            async with self.client.get(api_url) as response:
+                response.raise_for_status()
+                return await response.json()
         except (
             aiohttp.ClientConnectionError,
             aiohttp.ClientConnectorError,
         ) as e:
             raise APIUnavailableError(e) from e
-        return await response.json()
 
     async def _authentication(self, credentials: dict[str, str]) -> None:
         """Do the authentication process to Smartbox. First one use login/mdp/basic_auth. Then the tokens."""
         token_headers = self._headers.copy()
-        del token_headers["Authorization"]
+        token_headers.pop("Authorization", None)
         token_headers.update(
             {
                 "authorization": f"Basic {self.reseller.basic_auth}",
@@ -157,11 +186,40 @@ class AsyncSession:
 
         token_url = f"{self._api_host}/client/token"
         try:
-            response = await self.client.post(
+            async with self.client.post(
                 url=token_url,
                 headers=token_headers,
                 data=credentials,
-            )
+            ) as response:
+                response.raise_for_status()
+                response_json = await response.json()
+                try:
+                    rtoken: Token = Token.model_validate(response_json)
+                    self._access_token = rtoken.access_token
+                    self._headers["Authorization"] = (
+                        f"Bearer {self._access_token}"
+                    )
+                    self._refresh_token = rtoken.refresh_token
+                    if rtoken.expires_in < _MIN_TOKEN_LIFETIME:
+                        _LOGGER.warning(
+                            "Token expires in %ss which is below minimum lifetime of %ss- will refresh again on next operation",
+                            rtoken.expires_in,
+                            _MIN_TOKEN_LIFETIME,
+                        )
+                    self._expires_at = datetime.datetime.now(
+                        datetime.UTC
+                    ) + datetime.timedelta(
+                        seconds=rtoken.expires_in,
+                    )
+                    _LOGGER.debug(
+                        "Authenticated session (%s), access_token=%s, expires at %s",
+                        credentials["grant_type"],
+                        self.access_token,
+                        self.expiry_time,
+                    )
+                except ValidationError as e:
+                    msg = f"Received invalid auth response {response.status} with msg: {response.reason}"
+                    raise InvalidAuthError(msg) from e
         except (
             aiohttp.ClientConnectionError,
             aiohttp.ClientConnectorError,
@@ -169,31 +227,6 @@ class AsyncSession:
             raise APIUnavailableError(e) from e
         except aiohttp.ClientResponseError as e:
             raise InvalidAuthError(e) from e
-        try:
-            rtoken: Token = Token.model_validate(await response.json())
-            self._access_token = rtoken.access_token
-            self._headers["Authorization"] = f"Bearer {self._access_token}"
-            self._refresh_token = rtoken.refresh_token
-            if rtoken.expires_in < _MIN_TOKEN_LIFETIME:
-                _LOGGER.warning(
-                    "Token expires in %ss which is below minimum lifetime of %ss- will refresh again on next operation",
-                    rtoken.expires_in,
-                    _MIN_TOKEN_LIFETIME,
-                )
-            self._expires_at = datetime.datetime.now(
-                datetime.UTC
-            ) + datetime.timedelta(
-                seconds=rtoken.expires_in,
-            )
-            _LOGGER.debug(
-                "Authenticated session (%s), access_token=%s, expires at %s",
-                credentials["grant_type"],
-                self.access_token,
-                self.expiry_time,
-            )
-        except ValidationError as e:
-            msg = f"Received invalid auth response {response.status} with msg: {response.reason}"
-            raise InvalidAuthError(msg) from e
 
     async def check_refresh_auth(self) -> None:
         """Do we have to refresh auth."""
@@ -221,8 +254,13 @@ class AsyncSession:
         api_url = f"{self._api_host}/api/v2/{path}"
         try:
             _LOGGER.debug("Getting %s.", api_url)
-            response = await self.client.get(api_url, headers=self._headers)
-            _LOGGER.debug("Response %s.", (await response.json()))
+            async with self.client.get(
+                api_url, headers=self._headers
+            ) as response:
+                response.raise_for_status()
+                data = await response.json()
+                _LOGGER.debug("Response %s.", data)
+                return data
         except (
             aiohttp.ClientConnectionError,
             aiohttp.ClientConnectorError,
@@ -235,7 +273,6 @@ class AsyncSession:
                 e.status,
             )
             raise SmartboxError(e) from e
-        return await response.json()
 
     async def _api_post(
         self,
@@ -248,12 +285,13 @@ class AsyncSession:
         try:
             data_str = json.dumps(data)
             _LOGGER.debug("Posting %s to %s.", data_str, api_url)
-            response = await self.client.post(
-                api_url,
-                data=data_str,
-                headers=self._headers,
-            )
-            _LOGGER.debug("Response %s.", (await response.json()))
+            async with self.client.post(
+                api_url, headers=self._headers, data=data_str
+            ) as response:
+                response.raise_for_status()
+                data = await response.json()
+                _LOGGER.debug("Response %s.", data)
+                return data
         except (
             aiohttp.ClientConnectionError,
             aiohttp.ClientConnectorError,
@@ -266,7 +304,6 @@ class AsyncSession:
                 e.status,
             )
             raise SmartboxError(e) from e
-        return await response.json()
 
 
 class AsyncSmartboxSession(AsyncSession):

{smartbox-2.4.0 → smartbox-2.5.0}/src/smartbox/socket.py

@@ -2,6 +2,7 @@
 
 import asyncio
 from collections.abc import Callable
+import contextlib
 import logging
 import signal
 from typing import Any
@@ -14,8 +15,8 @@ from smartbox.session import AsyncSmartboxSession
 _API_V2_NAMESPACE = "/api/v2/socket_io"
 # We most commonly get disconnected when the session
 # expires, so we don't want to try many times
-_DEFAULT_RECONNECT_ATTEMPTS = 3
-_DEFAULT_BACKOFF_FACTOR = 0.1
+_DEFAULT_RECONNECT_ATTEMPTS = 10
+_DEFAULT_BACKOFF_FACTOR = 1.0
 
 _LOGGER = logging.getLogger(__name__)
 
@@ -106,17 +107,22 @@ class SocketSession:
         self._ping_interval = ping_interval
         self._reconnect_attempts = reconnect_attempts
         self._backoff_factor = backoff_factor
+        self._background_tasks: set[asyncio.Task] = set()
 
         if verbose:
             self._sio = socketio.AsyncClient(
                 logger=True,
                 engineio_logger=True,
-                reconnection_attempts=reconnect_attempts,
+                http_session=self._session.client,
+                reconnection=False,
             )
         else:
             logging.getLogger("socketio").setLevel(logging.ERROR)
             logging.getLogger("engineio").setLevel(logging.ERROR)
-            self._sio = socketio.AsyncClient()
+            self._sio = socketio.AsyncClient(
+                http_session=self._session.client,
+                reconnection=False,
+            )
 
         self._api_v2_ns = SmartboxAPIV2Namespace(
             session,
@@ -138,7 +144,9 @@ class SocketSession:
 
                 def sigint_handler() -> None:
                     _LOGGER.debug("Caught SIGINT, cancelling loop")
-                    asyncio.ensure_future(self.cancel())
+                    task = asyncio.ensure_future(self.cancel())
+                    self._background_tasks.add(task)
+                    task.add_done_callback(self._background_tasks.discard)
 
                 event_loop.add_signal_handler(signal.SIGINT, sigint_handler)
 
@@ -160,32 +168,101 @@ class SocketSession:
             _LOGGER.debug("Sending ping")
             await self._sio.send("ping", namespace=_API_V2_NAMESPACE)
 
+    async def _attempt_connection(self, url: str) -> bool:
+        """Attempt to connect to the websocket URL.
+
+        Returns True if connection was successful, False otherwise.
+        """
+        _LOGGER.debug("Connecting to %s", url)
+        try:
+            connect_task = asyncio.create_task(
+                self._sio.connect(url, transports=["websocket"])
+            )
+            try:
+                await asyncio.shield(connect_task)
+            except asyncio.CancelledError:
+                _LOGGER.debug(
+                    "HA stops during connection, scheduled cleaning..."
+                )
+                if not connect_task.done():
+
+                    async def _cleanup_dangling_socket(
+                        task_to_cleanup: asyncio.Task = connect_task,
+                    ) -> None:
+                        try:
+                            await task_to_cleanup
+                            await self._sio.disconnect()
+                        except (
+                            AttributeError,
+                            RuntimeError,
+                            OSError,
+                        ) as e:
+                            _LOGGER.debug(
+                                "Error occurred while _cleanup_dangling_socket: %s",
+                                e,
+                            )
+
+                    task = asyncio.create_task(_cleanup_dangling_socket())
+                    self._background_tasks.add(task)
+                    task.add_done_callback(self._background_tasks.discard)
+
+                raise
+            _LOGGER.info("Successfully connected to %s", url)
+            await self._dev_data()
+            await self._sio.wait()
+            await self._cleanup_websocket()
+            with contextlib.suppress(Exception):
+                await self._sio.disconnect()
+        except socketio.exceptions.ConnectionError:
+            return False
+        return True
+
+    async def _cleanup_websocket(self) -> None:
+        """Clean up orphaned WebSocket connections."""
+        _LOGGER.debug("Exiting wait(), forcing socketio cleanup...")
+        try:
+            if (
+                hasattr(self._sio, "eio")
+                and hasattr(self._sio.eio, "ws")
+                and self._sio.eio.ws
+            ) and not self._sio.eio.ws.closed:
+                _LOGGER.debug("Manually closing the orphaned WebSocket")
+                await self._sio.eio.ws.close()
+        except (AttributeError, RuntimeError, OSError) as e:
+            _LOGGER.debug(
+                "Error occurred while manually closing the WebSocket: %s",
+                e,
+            )
+
     async def run(self) -> None:
         """Run the websocket."""
         self._ping_task = self._sio.start_background_task(self._send_ping)
-
-        # Will loop indefinitely unless our signal handler is set and called
         self._loop_should_exit = False
 
         _LOGGER.debug("Starting main loop")
-        while not self._loop_should_exit:
-            encoded_token = urllib.parse.quote(
-                self._session.access_token,
-                safe="~()*!.'",
-            )
-            url = f"{self._session.api_host}/?token={encoded_token}&dev_id={self._device_id}"
+        try:
+            while not self._loop_should_exit:
+                encoded_token = urllib.parse.quote(
+                    self._session.access_token,
+                    safe="~()*!.'",
+                )
+                url = f"{self._session.api_host}/?token={encoded_token}&dev_id={self._device_id}"
+
+                # Try to connect
+                _LOGGER.debug(
+                    "Connecting to %s (will try %s times)",
+                    url,
+                    self._reconnect_attempts,
+                )
+                for attempt in range(self._reconnect_attempts):
+                    _LOGGER.debug(
+                        "Connecting to %s (attempt #%s)", url, attempt
+                    )
+
+                    if await self._attempt_connection(url):
+                        _LOGGER.debug("Breaking loop to refresh token")
+                        break
 
-            # Try to connect
-            _LOGGER.debug(
-                "Connecting to %s (will try %s times)",
-                url,
-                self._reconnect_attempts,
-            )
-            for attempt in range(self._reconnect_attempts):
-                _LOGGER.debug("Connecting to %s (attempt #%s)", url, attempt)
-                try:
-                    await self._sio.connect(url, transports=["websocket"])
-                except socketio.exceptions.ConnectionError:
                     remaining = self._reconnect_attempts - attempt - 1
                     sleep_time = self._backoff_factor * (2**attempt)
                     _LOGGER.exception(
@@ -200,31 +277,35 @@ class SocketSession:
                             "Failed to connect after %s attempts, falling through to refresh token",
                             self._reconnect_attempts,
                         )
-                else:
-                    _LOGGER.info("Successfully connected to %s", url)
-                    await self._dev_data()
-                    await self._sio.wait()
-                    _LOGGER.info("Socket loop exited, disconnecting")
-                    await self._sio.disconnect()
-                    _LOGGER.debug("Breaking loop to refresh token")
-                    break
-
-            # Refresh token
-            await self._session.check_refresh_auth()
-
-            # Update the query string with the new access token
-            encoded_token = urllib.parse.quote(
-                self._session.access_token,
-                safe="~()*!.'",
-            )
-            url = f"{self._session.api_host}/?token={encoded_token}&dev_id={self._device_id}"
+                await self._session.check_refresh_auth()
+        except asyncio.CancelledError:
+            _LOGGER.debug("WebSocket loop cancelled by Home Assistant")
+            raise
+        finally:
+            _LOGGER.debug("Cleaning up socketio...")
+            await self.shutdown()
 
     async def cancel(self) -> None:
         """Disconnecting and cancelling tasks."""
         _LOGGER.debug("Disconnecting and cancelling tasks")
         self._loop_should_exit = True
-        await self._sio.disconnect()
-        self._ping_task.cancel()
+        if hasattr(self, "_ping_task") and not self._ping_task.done():
+            self._ping_task.cancel()
+        try:
+            await asyncio.shield(self._sio.disconnect())
+        except (asyncio.CancelledError, OSError) as e:
+            _LOGGER.debug("Silent error on disconnect: %s", e)
+
+    async def shutdown(self) -> None:
+        """Shutdown the socket session."""
+        self._loop_should_exit = True
+        if hasattr(self, "_ping_task") and not self._ping_task.done():
+            self._ping_task.cancel()
+
+        try:
+            await asyncio.shield(self._sio.disconnect())
+        except (asyncio.CancelledError, OSError) as e:
+            _LOGGER.debug("Silent error on disconnect: %s", e)
 
     @property
     def namespace(self) -> SmartboxAPIV2Namespace:

{smartbox-2.4.0 → smartbox-2.5.0}/src/smartbox/update_manager.py

@@ -3,7 +3,7 @@
 from collections.abc import Callable, Iterable
 import logging
 import re
-from typing import Any
+from typing import Any, ClassVar
 
 import jq
 
@@ -18,6 +18,8 @@ _SIMPLE_JQ_RE = re.compile(r"^\.(\w+)$")
 class OptimisedJQMatcher:
     """jq matcher that doesn't bother with jq for simple one-level element queries."""
 
+    _jq_cache: ClassVar[dict[str, Any]] = {}
+
     def __init__(self, jq_expr: str) -> None:
         """Create an OptimisedJQMatcher for any jq expression."""
         m = _SIMPLE_JQ_RE.match(jq_expr)
@@ -26,7 +28,9 @@ class OptimisedJQMatcher:
             self._fast_path = True
             self._simple_elem = m.group(1)
         else:
-            self._compiled_jq = jq.compile(jq_expr)
+            if jq_expr not in self._jq_cache:
+                self._jq_cache[jq_expr] = jq.compile(jq_expr)
+            self._compiled_jq = self._jq_cache[jq_expr]
 
     def match(self, input_data: dict[str, Any]) -> Iterable[Any]:
         """Return matches for the given dev data."""