smartbox 2.1.2__tar.gz → 2.1.3__tar.gz

{smartbox-2.1.2 → smartbox-2.1.3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: smartbox
-Version: 2.1.2
+Version: 2.1.3
 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

{smartbox-2.1.2 → smartbox-2.1.3}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "smartbox"
-version = "2.1.2"
+version = "2.1.3"
 requires-python = ">=3.13"
 authors = [
   { name="Alberto Tudela", email="ajtudela@gmail.com" },

{smartbox-2.1.2 → smartbox-2.1.3}/src/smartbox/cmd.py

@@ -277,6 +277,21 @@ async def device_away_status(ctx) -> None:
         _pretty_print(device_away_status)
 
 
+@smartbox.command(help="Show device connected status")
+@click.pass_context
+async def device_connected_status(ctx) -> None:
+    """Show device connected status."""
+    session = ctx.obj["session"]
+    devices = await session.get_devices()
+
+    for device in devices:
+        print(f"{device['name']} (dev_id: {device['dev_id']})")
+        device_away_status = await session.get_device_connected(
+            device["dev_id"],
+        )
+        _pretty_print(device_away_status)
+
+
 @smartbox.command(
     help="Set device away_status (pass settings as extra args, e.g. away=true)",
 )
@@ -379,6 +394,15 @@ async def health_check(ctx) -> None:
     _pretty_print(health)
 
 
+@smartbox.command(help="Get version of the API.")
+@click.pass_context
+async def api_version(ctx) -> None:
+    """Get the version of the API."""
+    session = ctx.obj["session"]
+    version = await session.api_version()
+    _pretty_print(version)
+
+
 @smartbox.command(help="Get the availables resailers.")
 def resailers() -> None:
     """Get the availables resailers."""

{smartbox-2.1.2 → smartbox-2.1.3}/src/smartbox/models.py

@@ -47,7 +47,15 @@ class NodeExtraOptions(BaseModel):
     boost_time: int
 
 
-class NodeSetup(BaseModel):
+class PmoSetup(BaseModel):
+    """Pmo node setup."""
+
+    circuit_type: int
+    power_limit: int
+    reverse: bool
+
+
+class DefaultNodeSetup(BaseModel):
     """NodeSetup model."""
 
     sync_status: str
@@ -66,6 +74,16 @@ class NodeSetup(BaseModel):
     extra_options: NodeExtraOptions
 
 
+class NodeSetup(RootModel[DefaultNodeSetup | PmoSetup]):
+    """NodeSetup model."""
+
+    root: DefaultNodeSetup | PmoSetup
+
+    def __getattr__(self, name: str) -> DefaultNodeSetup | PmoSetup:
+        """Get the root model directly."""
+        return getattr(self.root, name)
+
+
 class DefaultNodeStatus(BaseModel):
     """Default Node Status."""
 
@@ -196,17 +214,26 @@ class Homes(RootModel[list[Home]]):
 
 
 class Sample(BaseModel):
-    """Sample model."""
+    """Pmo Sample model."""
 
     t: int
+    counter: float
     temp: str
-    counter: int
+
+
+class PmoSample(BaseModel):
+    """Default Sample."""
+
+    t: int
+    counter: float
+    max: int
+    min: int
 
 
 class Samples(BaseModel):
     """Samples model."""
 
-    samples: list[Sample]
+    samples: list[PmoSample | Sample]
 
 
 class Token(BaseModel):
@@ -229,3 +256,9 @@ class Guests(BaseModel):
     """Guests model."""
 
     guest_users: list[GuestUser]
+
+
+class DeviceConnected(BaseModel):
+    """Connected status of devices."""
+
+    connected: bool

{smartbox-2.1.2 → smartbox-2.1.3}/src/smartbox/resailer.py

@@ -31,6 +31,12 @@ class AvailableResailers:
             api_url="api",
             serial_id=1,
         ),
+        "api-ehc": SmartboxResailer(
+            name="Electric Heating Company",
+            web_url="https://control.electric-heatingcompany.co.uk/",
+            api_url="api-ehc",
+            serial_id=3,
+        ),
         "api-climastar": SmartboxResailer(
             name="Climastar",
             web_url="https://avantwifi.climastar.es/",

{smartbox-2.1.2 → smartbox-2.1.3}/src/smartbox/session.py

@@ -16,6 +16,7 @@ from smartbox.models import (
     AcmNodeStatus,
     DefaultNodeStatus,
     DeviceAwayStatus,
+    DeviceConnected,
     Devices,
     Guests,
     Home,
@@ -131,6 +132,18 @@ class AsyncSession:
             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)
+        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()
@@ -209,6 +222,7 @@ class AsyncSession:
         try:
             _LOGGER.debug("Getting %s.", api_url)
             response = await self.client.get(api_url, headers=self._headers)
+            _LOGGER.debug("Response %s.", (await response.json()))
         except (
             aiohttp.ClientConnectionError,
             aiohttp.ClientConnectorError,
@@ -239,6 +253,7 @@ class AsyncSession:
                 data=data_str,
                 headers=self._headers,
             )
+            _LOGGER.debug("Response %s.", (await response.json()))
         except (
             aiohttp.ClientConnectionError,
             aiohttp.ClientConnectorError,
@@ -306,6 +321,17 @@ class AsyncSmartboxSession(AsyncSession):
             return response["nodes"]
         return Nodes.model_validate(response).nodes
 
+    async def get_device_connected(
+        self,
+        device_id: str,
+    ) -> dict[str, bool] | DeviceConnected:
+        """Get device away status."""
+        response = await self._api_request(f"devs/{device_id}/connected")
+        status: DeviceConnected = DeviceConnected.model_validate(response)
+        if self.raw_response is False:
+            return status
+        return status.model_dump(mode="json")
+
     async def get_device_away_status(
         self,
         device_id: str,
@@ -333,15 +359,18 @@ class AsyncSmartboxSession(AsyncSession):
         self, device_id: str, node: dict[str, Any] | None = None
     ) -> int:
         """Get device power limit."""
-        url = f"devs/{device_id}/htr_system/power_limit"
+        power_param = "power_limit"
+        url = f"devs/{device_id}/htr_system/{power_param}"
+
         if node is not None and (
             (_node := Node.model_validate(node))
             and _node.type == SmartboxNodeType.PMO
         ):
-            url = f"devs/{device_id}/{_node.type}/{_node.addr}/power"
+            power_param = "power"
+            url = f"devs/{device_id}/{_node.type}/{_node.addr}/{power_param}"
 
         resp = await self._api_request(url)
-        return int(resp["power_limit"])
+        return int(resp[power_param])
 
     async def set_device_power_limit(
         self,
@@ -380,14 +409,13 @@ class AsyncSmartboxSession(AsyncSession):
             datetime.datetime.fromtimestamp(end_time, tz=datetime.UTC),
         )
         _node: Node = Node.model_validate(node)
-        samples = Samples.model_validate(
-            await self._api_request(
-                f"devs/{device_id}/{_node.type}/{_node.addr}/samples?start={start_time}&end={end_time}",
-            ),
+        response = await self._api_request(
+            f"devs/{device_id}/{_node.type}/{_node.addr}/samples?start={start_time}&end={end_time}",
         )
-        if self.raw_response is False:
-            return samples
-        return samples.model_dump(mode="json")
+        _LOGGER.debug("Get_Device_Samples_Node: %s", response)
+        if self.raw_response is True:
+            return response
+        return Samples.model_validate(response)
 
     async def get_node_status(
         self,
@@ -399,6 +427,7 @@ class AsyncSmartboxSession(AsyncSession):
         | HtrNodeStatus
         | HtrModNodeStatus
         | DefaultNodeStatus
+        | None
     ):
         """Get a node status."""
         _node: Node = Node.model_validate(node)
@@ -461,9 +490,12 @@ class AsyncSmartboxSession(AsyncSession):
         data = {k: v for k, v in setup_args.items() if v is not None}
         # setup seems to require all settings to be re-posted, so get current
         # values and update
-        setup_data = await self.get_node_setup(device_id, node)
-        if isinstance(setup_data, NodeSetup):
-            setup_data = setup_data.model_dump(mode="json")
+        setup_data: dict[str, Any] = {}
+        node_setup = await self.get_node_setup(device_id, node)
+        if not isinstance(node_setup, dict):
+            setup_data = node_setup.model_dump(mode="json")
+        else:
+            setup_data = node_setup
         setup_data.update(data)
         await self._api_post(
             data=setup_data,

{smartbox-2.1.2 → smartbox-2.1.3}/src/smartbox/socket.py

@@ -143,6 +143,13 @@ class SocketSession:
 
                 event_loop.add_signal_handler(signal.SIGINT, sigint_handler)
 
+    async def _dev_data(self) -> None:
+        """Send first dev data."""
+        if not self._api_v2_ns.connected:
+            _LOGGER.debug("Namespace disconnected, not sending ping")
+        _LOGGER.debug("Sending dev_data event")
+        await self._sio.emit("dev_data", namespace=_API_V2_NAMESPACE)
+
     async def _send_ping(self) -> None:
         """End pings to be alive."""
         _LOGGER.debug("Starting ping task every %ss", self._ping_interval)
@@ -196,6 +203,7 @@ class SocketSession:
                         )
                 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()

{smartbox-2.1.2 → smartbox-2.1.3}/src/smartbox/update_manager.py

@@ -133,6 +133,10 @@ class UpdateManager:
         """Run the socket session asynchronously, waiting for updates."""
         await self._socket_session.run()
 
+    async def cancel(self) -> None:
+        """Disconnecting and cancelling tasks."""
+        await self._socket_session.cancel()
+
     def subscribe_to_dev_data(self, jq_expr: str, callback: Callable) -> None:
         """Subscribe to receive device data."""
         sub = DevDataSubscription(jq_expr, callback)
@@ -163,6 +167,21 @@ class UpdateManager:
             callback,
         )
 
+    def subscribe_to_device_connected(
+        self,
+        callback: Callable[[bool], None],
+    ) -> None:
+        """Subscribe to device power limit updates."""
+        self.subscribe_to_dev_data(
+            ".connected",
+            lambda p: callback(bool(p)),
+        )
+        self.subscribe_to_updates(
+            r"^/connected",
+            f"{self.BODY_PATH}.connected",
+            lambda p: callback(bool(p)),
+        )
+
     def subscribe_to_device_power_limit(
         self,
         callback: Callable[[int], None],

smartbox-2.1.3/tests/fixtures/devs/device1/connected.json

@@ -0,0 +1,3 @@
+{
+    "connected": true
+}

smartbox-2.1.3/tests/fixtures/devs/device1/mgr/nodes.json

@@ -0,0 +1,31 @@
+{
+    "nodes": [
+        {
+            "addr": 0,
+            "installed": true,
+            "lost": false,
+            "name": "Node 1 0",
+            "type": "htr"
+        },
+        {
+            "addr": 1,
+            "installed": true,
+            "lost": false,
+            "name": "Node 1 1",
+            "type": "acm"
+        },
+        {
+            "addr": 3,
+            "installed": true,
+            "level": 1,
+            "lost": false,
+            "name": "Node 1 3",
+            "parent": 1,
+            "setup": {
+                "counter_offset": "679.33"
+            },
+            "type": "pmo",
+            "uid": "003E003F0D47373436363733"
+        }
+    ]
+}

smartbox-2.1.3/tests/fixtures/devs/device1/pmo/3/samples.json

@@ -0,0 +1,16 @@
+{
+    "samples": [
+        {
+            "counter": "16612253.89",
+            "max": "2411",
+            "min": "166",
+            "t": 1738360800
+        },
+        {
+            "counter": "16612548.73",
+            "max": "2185",
+            "min": "164",
+            "t": 1738361700
+        }
+    ]
+}

smartbox-2.1.3/tests/fixtures/devs/device1/pmo/3/setup.json

@@ -0,0 +1,5 @@
+{
+    "circuit_type": 0,
+    "power_limit": 0,
+    "reverse": false
+}

smartbox-2.1.3/tests/fixtures/devs/device1/pmo/3/status.json

@@ -0,0 +1,4 @@
+{
+    "message": "Not Found",
+    "statusCode": 404
+}

smartbox-2.1.3/tests/fixtures/devs/device2/connected.json

@@ -0,0 +1,3 @@
+{
+    "connected": false
+}

{smartbox-2.1.2 → smartbox-2.1.3}/tests/test_cmd.py

@@ -28,6 +28,22 @@ async def test_health_check(runner, mock_session):
     assert "" in result.output
 
 
+@pytest.mark.anyio
+async def test_api_version(runner, mock_session):
+    devices_future = asyncio.Future()
+    devices_future.set_result(
+        {"major": "1", "minor": "53", "subminor": "2", "commit": "NULL"}
+    )
+    mock_session.return_value.api_version.return_value = devices_future
+
+    result = await runner.invoke(
+        smartbox,
+        [*DEFAULT_ARGS, "api-version"],
+    )
+    assert result.exit_code == 0
+    assert "subminor" in result.output
+
+
 @pytest.mark.anyio
 async def test_devices(runner, async_smartbox_session):
     result = await runner.invoke(
@@ -365,3 +381,13 @@ async def test_guests(runner, mock_session):
     mock_session.return_value.get_home_guests.assert_called_once_with(
         home_id="home1"
     )
+
+
+@pytest.mark.anyio
+async def test_device_connected_status(runner, async_smartbox_session):
+    result = await runner.invoke(
+        smartbox,
+        [*DEFAULT_ARGS, "device-connected-status"],
+    )
+    assert result.exit_code == 0
+    assert "connected" in result.output

{smartbox-2.1.2 → smartbox-2.1.3}/tests/test_resailer.py

@@ -1,6 +1,6 @@
 import pytest
 
-from smartbox import ResailerNotExistError
+from smartbox import AsyncSmartboxSession, ResailerNotExistError
 from smartbox.resailer import AvailableResailers
 
 
@@ -44,3 +44,15 @@ def test_resailer_invalid_data():
             web_url="invalid-url",
             serial_id="invalid-serial-id",
         ).resailer
+
+
+@pytest.mark.asyncio
+async def test_all_resailers():
+    for resailer in AvailableResailers.resailers.values():
+        _session = AsyncSmartboxSession(
+            username="", password="", api_name=resailer.api_url
+        )
+        check = await _session.health_check()
+        assert check is not None
+        version = await _session.api_version()
+        assert "major" in version

{smartbox-2.1.2 → smartbox-2.1.3}/tests/test_session.py

@@ -9,7 +9,7 @@ from pydantic import ValidationError
 import pytest
 
 from smartbox import APIUnavailableError, InvalidAuthError, SmartboxError
-from smartbox.models import NodeSetup
+from smartbox.models import DefaultNodeSetup, NodeSetup
 from smartbox.session import (
     _DEFAULT_BACKOFF_FACTOR,
     _DEFAULT_RETRY_ATTEMPTS,
@@ -90,11 +90,12 @@ async def test_get_node_status(async_smartbox_session, caplog):
                 mock_api_request.assert_called_with(url)
 
                 async_smartbox_session.raw_response = False
-                status_model = await async_smartbox_session.get_node_status(
-                    mock_device["dev_id"],
-                    mock_node,
-                )
-                assert status_model.act_duty == status["act_duty"]
+                if mock_node["type"] != "pmo":
+                    status_model = await async_smartbox_session.get_node_status(
+                        mock_device["dev_id"],
+                        mock_node,
+                    )
+                    assert status_model.act_duty == status["act_duty"]
                 with pytest.raises(ValidationError):
                     mock_api_request.return_value = {
                         "sync_status": "synced",
@@ -145,9 +146,8 @@ async def test_get_node_samples(async_smartbox_session):
                     start_time=start_time,
                     end_time=end_time,
                 )
-                assert (
-                    samples_model.samples[0].counter
-                    == samples["samples"][0]["counter"]
+                assert samples_model.samples[0].counter == float(
+                    samples["samples"][0]["counter"]
                 )
                 async_smartbox_session.raw_response = True
 
@@ -223,6 +223,7 @@ async def test_get_device_power_limit(async_smartbox_session):
             "devs/test_device/htr_system/power_limit",
         )
 
+        mock_api_request.return_value = {"power": "100"}
         power_limit = await async_smartbox_session.get_device_power_limit(
             device_id="test_device", node=mock_node
         )
@@ -921,6 +922,54 @@ async def test_health_check_api_unavailable(async_session):
         )
 
 
+@pytest.mark.asyncio
+async def test_api_version_success(async_session):
+    with patch.object(
+        async_session.client,
+        "get",
+        new_callable=AsyncMock,
+    ) as mock_get:
+        mock_response = AsyncMock()
+        mock_response.json = AsyncMock(
+            return_value={
+                "major": "1",
+                "minor": "53",
+                "subminor": "2",
+                "commit": "NULL",
+            }
+        )
+        mock_response.raise_for_status = AsyncMock()
+        mock_get.return_value = mock_response
+
+        result = await async_session.api_version()
+        assert result == {
+            "major": "1",
+            "minor": "53",
+            "subminor": "2",
+            "commit": "NULL",
+        }
+        mock_get.assert_called_once_with(
+            f"{async_session._api_host}/version",
+        )
+
+
+@pytest.mark.asyncio
+async def test_api_version_unavailable(async_session):
+    with patch.object(
+        async_session.client,
+        "get",
+        new_callable=AsyncMock,
+    ) as mock_get:
+        mock_get.side_effect = aiohttp.ClientConnectionError()
+
+        with pytest.raises(APIUnavailableError):
+            await async_session.api_version()
+
+        mock_get.assert_called_once_with(
+            f"{async_session._api_host}/version",
+        )
+
+
 @pytest.mark.asyncio
 async def test_api_request_success(async_session):
     path = "test_path"
@@ -1256,7 +1305,8 @@ async def test_get_node_setup(async_smartbox_session, caplog):
                     device_id=mock_device_id,
                     node=mock_node,
                 )
-                assert setup_model.away_mode == setup["away_mode"]
+                if isinstance(setup_model, DefaultNodeSetup):
+                    assert setup_model.away_mode == setup["away_mode"]
                 with pytest.raises(ValidationError):
                     mock_api_request.return_value = {
                         "sync_status": "synced",
@@ -1396,3 +1446,30 @@ async def test_get_home_guests(async_smartbox_session):
         )
         assert guests_model.guest_users[0].email == guests[0]["email"]
         async_smartbox_session.raw_response = True
+
+
+@pytest.mark.asyncio
+async def test_get_deviceconnected_status(async_smartbox_session):
+    for mock_device in await async_smartbox_session.get_devices():
+        with patch.object(
+            async_smartbox_session,
+            "_api_request",
+            new_callable=AsyncMock,
+        ) as mock_api_request:
+            url = f"devs/{mock_device['dev_id']}/connected"
+            mock_api_request.return_value = await fake_get_request(
+                mock_api_request,
+                url,
+            )
+            nodes = await async_smartbox_session.get_device_connected(
+                device_id=mock_device["dev_id"],
+            )
+            assert nodes == mock_api_request.return_value
+            mock_api_request.assert_called_with(url)
+
+            async_smartbox_session.raw_response = False
+            nodes_model = await async_smartbox_session.get_device_connected(
+                device_id=mock_device["dev_id"],
+            )
+            assert nodes_model.connected == nodes["connected"]
+            async_smartbox_session.raw_response = True

{smartbox-2.1.2 → smartbox-2.1.3}/tests/test_update_manager.py

@@ -206,3 +206,21 @@ async def test_update_manager_run(update_manager):
     ) as mock_run:
         await update_manager.run()
         mock_run.assert_awaited_once()
+
+
+def test_update_manager_subscribe_to_device_connected(update_manager):
+    callback = MagicMock()
+    update_manager.subscribe_to_device_connected(callback)
+    assert len(update_manager._dev_data_subscriptions) == 1
+    assert len(update_manager._update_subscriptions) == 1
+
+    # Test dev data callback
+    dev_data = {"connected": True}
+    update_manager._dev_data_cb(dev_data)
+    callback.assert_called_once_with(dev_data["connected"])
+
+    # Test update callback
+    callback.reset_mock()
+    update_data = {"path": "/connected", "body": {"connected": True}}
+    update_manager._update_cb(update_data)
+    callback.assert_called_once_with(update_data["body"]["connected"])

{smartbox-2.1.2 → smartbox-2.1.3}/uv.lock

@@ -1,4 +1,5 @@
 version = 1
+revision = 1
 requires-python = ">=3.13"
 
 [[package]]
@@ -684,7 +685,7 @@ wheels = [
 
 [[package]]
 name = "smartbox"
-version = "2.1.2"
+version = "2.1.3"
 source = { editable = "." }
 dependencies = [
     { name = "aiohttp" },

smartbox-2.1.2/requirements.txt

@@ -1,2 +0,0 @@
-# install from setup.py
-.

smartbox-2.1.2/tests/fixtures/devs/device1/mgr/nodes.json

@@ -1,18 +0,0 @@
-{
-  "nodes": [
-    {
-      "addr": 0,
-      "name": "Node 1 0",
-      "type": "htr",
-      "installed": true,
-      "lost": false
-    },
-    {
-      "addr": 1,
-      "name": "Node 1 1",
-      "type": "acm",
-      "installed": true,
-      "lost": false
-    }
-  ]
-}