aiorexense 0.1.1__tar.gz

aiorexense-0.1.1/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 Zhejiang Rexense IoT Technology Co., Ltd
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the “Software”), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED “AS IS”, WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

aiorexense-0.1.1/PKG-INFO

@@ -0,0 +1,47 @@
+Metadata-Version: 2.4
+Name: aiorexense
+Version: 0.1.1
+Summary: Rexense device client library: HTTP API + WebSocket
+Home-page: https://github.com/RexenseIoT/aiorexense.git
+Author: Zhejiang Rexense IoT Technology Co., Ltd
+Author-email: RexenseIoT <yuxiaoqiang@rexense.com>
+License: MIT License
+        
+        Copyright (c) 2025 Zhejiang Rexense IoT Technology Co., Ltd
+        
+        Permission is hereby granted, free of charge, to any person obtaining a copy
+        of this software and associated documentation files (the “Software”), to deal
+        in the Software without restriction, including without limitation the rights
+        to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+        copies of the Software, and to permit persons to whom the Software is
+        furnished to do so, subject to the following conditions:
+        
+        The above copyright notice and this permission notice shall be included in all
+        copies or substantial portions of the Software.
+        
+        THE SOFTWARE IS PROVIDED “AS IS”, WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+        IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+        FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+        AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+        LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+        OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+        SOFTWARE.
+        
+Project-URL: Homepage, https://github.com/RexenseIoT/aiorexense.git
+Project-URL: Repository, https://github.com/RexenseIoT/aiorexense.git
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: aiohttp>=3.8.0
+Dynamic: author
+Dynamic: home-page
+Dynamic: license-file
+Dynamic: requires-python
+
+# aiorexense
+
+A Rexense device client library featuring an HTTP API for retrieving basic information and WebSocket-based status push functionality.
+
+## Install
+```bash
+pip install aiorexense

aiorexense-0.1.1/README.md

@@ -0,0 +1,7 @@
+# aiorexense
+
+A Rexense device client library featuring an HTTP API for retrieving basic information and WebSocket-based status push functionality.
+
+## Install
+```bash
+pip install aiorexense

aiorexense-0.1.1/aiorexense.egg-info/PKG-INFO

@@ -0,0 +1,47 @@
+Metadata-Version: 2.4
+Name: aiorexense
+Version: 0.1.1
+Summary: Rexense device client library: HTTP API + WebSocket
+Home-page: https://github.com/RexenseIoT/aiorexense.git
+Author: Zhejiang Rexense IoT Technology Co., Ltd
+Author-email: RexenseIoT <yuxiaoqiang@rexense.com>
+License: MIT License
+        
+        Copyright (c) 2025 Zhejiang Rexense IoT Technology Co., Ltd
+        
+        Permission is hereby granted, free of charge, to any person obtaining a copy
+        of this software and associated documentation files (the “Software”), to deal
+        in the Software without restriction, including without limitation the rights
+        to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+        copies of the Software, and to permit persons to whom the Software is
+        furnished to do so, subject to the following conditions:
+        
+        The above copyright notice and this permission notice shall be included in all
+        copies or substantial portions of the Software.
+        
+        THE SOFTWARE IS PROVIDED “AS IS”, WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+        IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+        FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+        AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+        LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+        OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+        SOFTWARE.
+        
+Project-URL: Homepage, https://github.com/RexenseIoT/aiorexense.git
+Project-URL: Repository, https://github.com/RexenseIoT/aiorexense.git
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: aiohttp>=3.8.0
+Dynamic: author
+Dynamic: home-page
+Dynamic: license-file
+Dynamic: requires-python
+
+# aiorexense
+
+A Rexense device client library featuring an HTTP API for retrieving basic information and WebSocket-based status push functionality.
+
+## Install
+```bash
+pip install aiorexense

aiorexense-0.1.1/aiorexense.egg-info/SOURCES.txt

@@ -0,0 +1,16 @@
+LICENSE
+README.md
+pyproject.toml
+setup.py
+aiorexense.egg-info/PKG-INFO
+aiorexense.egg-info/SOURCES.txt
+aiorexense.egg-info/dependency_links.txt
+aiorexense.egg-info/requires.txt
+aiorexense.egg-info/top_level.txt
+src/__init__.py
+src/api.py
+src/const.py
+src/ws_client.py
+tests/test_api.py
+tests/test_const.py
+tests/test_ws_client.py

aiorexense-0.1.1/aiorexense.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

aiorexense-0.1.1/aiorexense.egg-info/requires.txt

@@ -0,0 +1 @@
+aiohttp>=3.8.0

aiorexense-0.1.1/aiorexense.egg-info/top_level.txt

@@ -0,0 +1,4 @@
+aiorexense
+api
+const
+ws_client

aiorexense-0.1.1/pyproject.toml

@@ -0,0 +1,19 @@
+[build-system]
+requires = ["setuptools>=61.0", "wheel"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "aiorexense"
+version = "0.1.1"
+description = "Rexense device client library: HTTP API + WebSocket"
+readme = "README.md"
+license = { file = "LICENSE" }
+authors = [ { name = "RexenseIoT", email = "yuxiaoqiang@rexense.com" } ]
+requires-python = ">=3.8"
+dependencies = [
+  "aiohttp>=3.8.0"
+]
+
+[project.urls]
+"Homepage" = "https://github.com/RexenseIoT/aiorexense.git"
+"Repository" = "https://github.com/RexenseIoT/aiorexense.git"

aiorexense-0.1.1/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

aiorexense-0.1.1/setup.py

@@ -0,0 +1,34 @@
+#!/usr/bin/env python
+# setup.py
+
+import pathlib
+from setuptools import setup, find_packages
+
+HERE = pathlib.Path(__file__).parent
+
+# long_description from your README
+long_description = (HERE / "README.md").read_text(encoding="utf-8")
+
+setup(
+    name="aiorexense",
+    version="0.1.0",
+    description="Rexense device client library with HTTP API and WebSocket support",
+    long_description=long_description,
+    long_description_content_type="text/markdown",
+    author="Zhejiang Rexense IoT Technology Co., Ltd",
+    license="MIT License",
+    package_dir={"aiorexense": "src"},
+    packages=["aiorexense"],
+    url="https://github.com/RexenseIoT/aiorexense.git",  # adjust as needed
+    python_requires=">=3.8",
+    install_requires=[
+        "aiohttp>=3.8.0",
+    ],
+    # since your modules live at the top level:
+    py_modules=["api", "const", "ws_client"],
+    classifiers=[
+        "Programming Language :: Python :: 3",
+        "License :: OSI Approved :: MIT License",
+        "Operating System :: OS Independent",
+    ],
+)

aiorexense-0.1.1/src/__init__.py

@@ -0,0 +1,86 @@
+"""
+Rexense WS client library init.
+"""
+
+__version__ = "0.1.1"
+
+from .api import get_basic_info
+from .const import (
+    DEFAULT_PORT,
+    VENDOR_CODE,
+    API_VERSION,
+    FUNCTION_GET_BASIC_INFO,
+    FUNCTION_NOTIFY_STATUS,
+    FUNCTION_INVOKE_CMD,
+    REXENSE_SENSOR_CURRENT,
+    REXENSE_SENSOR_VOLTAGE,
+    REXENSE_SENSOR_POWER_FACTOR,
+    REXENSE_SENSOR_ACTIVE_POWER,
+    REXENSE_SENSOR_APPARENT_POWER,
+    REXENSE_SENSOR_B_CURRENT,
+    REXENSE_SENSOR_B_VOLTAGE,
+    REXENSE_SENSOR_B_POWER_FACTOR,
+    REXENSE_SENSOR_B_ACTIVE_POWER,
+    REXENSE_SENSOR_B_APPARENT_POWER,
+    REXENSE_SENSOR_C_CURRENT,
+    REXENSE_SENSOR_C_VOLTAGE,
+    REXENSE_SENSOR_C_POWER_FACTOR,
+    REXENSE_SENSOR_C_ACTIVE_POWER,
+    REXENSE_SENSOR_C_APPARENT_POWER,
+    REXENSE_SENSOR_TOTAL_ACTIVE_POWER,
+    REXENSE_SENSOR_TOTAL_APPARENT_POWER,
+    REXENSE_SENSOR_CEI,
+    REXENSE_SENSOR_CEE,
+    REXENSE_SENSOR_A_CEI,
+    REXENSE_SENSOR_A_CEE,
+    REXENSE_SENSOR_B_CEI,
+    REXENSE_SENSOR_B_CEE,
+    REXENSE_SENSOR_C_CEI,
+    REXENSE_SENSOR_C_CEE,
+    REXENSE_SENSOR_TEMPERATURE,
+    REXENSE_SENSOR_BATTERY_PERCENTAGE,
+    REXENSE_SENSOR_BATTERY_VOLTAGE,
+    REXENSE_SWITCH_ONOFF,
+)
+from .ws_client import RexenseWebsocketClient
+
+__all__ = [
+    "get_basic_info",
+    "RexenseWebsocketClient",
+    # constants
+    "DEFAULT_PORT",
+    "VENDOR_CODE",
+    "API_VERSION",
+    "FUNCTION_GET_BASIC_INFO",
+    "FUNCTION_NOTIFY_STATUS",
+    "FUNCTION_INVOKE_CMD",
+    "REXENSE_SENSOR_CURRENT",
+    "REXENSE_SENSOR_VOLTAGE",
+    "REXENSE_SENSOR_POWER_FACTOR",
+    "REXENSE_SENSOR_ACTIVE_POWER",
+    "REXENSE_SENSOR_APPARENT_POWER",
+    "REXENSE_SENSOR_B_CURRENT",
+    "REXENSE_SENSOR_B_VOLTAGE",
+    "REXENSE_SENSOR_B_POWER_FACTOR",
+    "REXENSE_SENSOR_B_ACTIVE_POWER",
+    "REXENSE_SENSOR_B_APPARENT_POWER",
+    "REXENSE_SENSOR_C_CURRENT",
+    "REXENSE_SENSOR_C_VOLTAGE",
+    "REXENSE_SENSOR_C_POWER_FACTOR",
+    "REXENSE_SENSOR_C_ACTIVE_POWER",
+    "REXENSE_SENSOR_C_APPARENT_POWER",
+    "REXENSE_SENSOR_TOTAL_ACTIVE_POWER",
+    "REXENSE_SENSOR_TOTAL_APPARENT_POWER",
+    "REXENSE_SENSOR_CEI",
+    "REXENSE_SENSOR_CEE",
+    "REXENSE_SENSOR_A_CEI",
+    "REXENSE_SENSOR_A_CEE",
+    "REXENSE_SENSOR_B_CEI",
+    "REXENSE_SENSOR_B_CEE",
+    "REXENSE_SENSOR_C_CEI",
+    "REXENSE_SENSOR_C_CEE",
+    "REXENSE_SENSOR_TEMPERATURE",
+    "REXENSE_SENSOR_BATTERY_PERCENTAGE",
+    "REXENSE_SENSOR_BATTERY_VOLTAGE",
+    "REXENSE_SWITCH_ONOFF",
+]

aiorexense-0.1.1/src/api.py

@@ -0,0 +1,61 @@
+"""
+HTTP API for Rexense device basic info
+"""
+import asyncio
+import logging
+from typing import Any, Tuple
+
+from aiohttp import ClientSession, ClientError
+
+from .const import (
+    API_VERSION,
+    VENDOR_CODE,
+    FUNCTION_GET_BASIC_INFO,
+)
+
+_LOGGER = logging.getLogger(__name__)
+
+
+async def get_basic_info(
+    host: str,
+    port: int,
+    session: ClientSession,
+    timeout: int = 5,
+) -> Tuple[str, str, str, list[dict[str, Any]]]:
+    """
+    Send an HTTP request to the device, query device_id, model, sw_build_id, feature_map。
+    """
+    url = f"http://{host}:{port}/rex/device/v1/operate"
+    payload = {
+        "Version": API_VERSION,
+        "VendorCode": VENDOR_CODE,
+        "Timestamp": "0",
+        "Seq": "0",
+        "DeviceId": "",
+        "FunctionCode": FUNCTION_GET_BASIC_INFO,
+        "Payload": {},
+    }
+    try:
+        async with asyncio.timeout(timeout):
+            resp = await session.get(url, json=payload)
+    except (asyncio.TimeoutError, ClientError) as err:
+        _LOGGER.error("HTTP get_basic_info failed: %s", err)
+        raise
+
+    if resp.status != 200:
+        _LOGGER.error("Device %s:%s HTTP status %s", host, port, resp.status)
+        raise ClientError(f"Status {resp.status}")
+
+    data = await resp.json()
+
+    if data.get("FunctionCode") != FUNCTION_GET_BASIC_INFO.replace("GetBasic", "ReportBasic") or not data.get("Payload"):
+        _LOGGER.error("Invalid response format: %s", data)
+        raise ClientError("Invalid response format")
+
+    device_id = data.get("DeviceId", "")
+    payload = data["Payload"]
+    model = payload.get("ModelId", "")
+    sw_build_id = payload.get("SwBuildId", "")
+    feature_map = payload.get("FeatureMap", [])
+
+    return device_id, model, sw_build_id, feature_map

aiorexense-0.1.1/src/const.py

@@ -0,0 +1,42 @@
+"""
+Rexense const & sensor config
+"""
+
+DEFAULT_PORT = 80
+
+API_VERSION = "1.0"
+VENDOR_CODE = "Rexense"
+FUNCTION_GET_BASIC_INFO = "GetBasicInfo"
+FUNCTION_NOTIFY_STATUS = "NotifyStatus"
+FUNCTION_INVOKE_CMD = "InvokeCmd"
+
+REXENSE_SENSOR_CURRENT = {"name":"Current","unit":"A"}
+REXENSE_SENSOR_VOLTAGE = {"name":"Voltage","unit":"V"}
+REXENSE_SENSOR_POWER_FACTOR = {"name":"PowerFactor","unit":"%"}
+REXENSE_SENSOR_ACTIVE_POWER = {"name":"ActivePower","unit":"W"}
+REXENSE_SENSOR_APPARENT_POWER = {"name":"AprtPower","unit":"VA"}
+REXENSE_SENSOR_B_CURRENT = {"name":"B_Current","unit":"A"}
+REXENSE_SENSOR_B_VOLTAGE = {"name":"B_Voltage","unit":"V"}
+REXENSE_SENSOR_B_POWER_FACTOR = {"name":"B_PowerFactor","unit":"%"}
+REXENSE_SENSOR_B_ACTIVE_POWER = {"name":"B_ActivePower","unit":"W"}
+REXENSE_SENSOR_B_APPARENT_POWER = {"name":"B_AprtPower","unit":"VA"}
+REXENSE_SENSOR_C_CURRENT = {"name":"C_Current","unit":"A"}
+REXENSE_SENSOR_C_VOLTAGE = {"name":"C_Voltage","unit":"V"}
+REXENSE_SENSOR_C_POWER_FACTOR = {"name":"C_PowerFactor","unit":"%"}
+REXENSE_SENSOR_C_ACTIVE_POWER = {"name":"C_ActivePower","unit":"W"}
+REXENSE_SENSOR_C_APPARENT_POWER = {"name":"C_AprtPower","unit":"VA"}
+REXENSE_SENSOR_TOTAL_ACTIVE_POWER = {"name":"TotalActivePower","unit":"W"}
+REXENSE_SENSOR_TOTAL_APPARENT_POWER = {"name":"TotalAprtPower","unit":"VA"}
+REXENSE_SENSOR_CEI = {"name":"CEI","unit":"Wh"}
+REXENSE_SENSOR_CEE = {"name":"CEE","unit":"Wh"}
+REXENSE_SENSOR_A_CEI = {"name":"A_CEI","unit":"Wh"}
+REXENSE_SENSOR_A_CEE = {"name":"A_CEE","unit":"Wh"}
+REXENSE_SENSOR_B_CEI = {"name":"B_CEI","unit":"Wh"}
+REXENSE_SENSOR_B_CEE = {"name":"B_CEE","unit":"Wh"}
+REXENSE_SENSOR_C_CEI = {"name":"C_CEI","unit":"Wh"}
+REXENSE_SENSOR_C_CEE = {"name":"C_CEE","unit":"Wh"}
+REXENSE_SENSOR_TEMPERATURE = {"name":"Temperature","unit":"°C"}
+REXENSE_SENSOR_BATTERY_PERCENTAGE = {"name":"BatteryPercentage","unit":"%"}
+REXENSE_SENSOR_BATTERY_VOLTAGE = {"name":"BatteryVoltage","unit":"V"}
+
+REXENSE_SWITCH_ONOFF = {"name":"PowerSwitch","unit":""}

aiorexense-0.1.1/src/ws_client.py

@@ -0,0 +1,197 @@
+"""
+WebSocket client for Rexense devices, independent of Home Assistant.
+"""
+import asyncio
+import logging
+from typing import Any, Callable, Optional
+
+from aiohttp import ClientSession, ClientWebSocketResponse, ClientWSTimeout, WSMsgType
+from .const import REXENSE_SWITCH_ONOFF
+
+_LOGGER = logging.getLogger(__name__)
+
+
+class RexenseWebsocketClient:
+    """
+    Manages WebSocket connection to a Rexense device.
+    """
+
+    def __init__(
+        self,
+        device_id: str,
+        model: str,
+        url: str,
+        sw_build_id: str,
+        feature_map: list[dict[str, Any]],
+        session: Optional[ClientSession] = None,
+        on_update: Optional[Callable[[], None]] = None,
+    ) -> None:
+        """Initialize the WebSocket client."""
+        self.device_id = device_id
+        self.model = model
+        self.sw_build_id = sw_build_id
+        self.feature_map = feature_map
+        self.url = url
+        self.ws: Optional[ClientWebSocketResponse] = None
+        self.connected: bool = False
+        self._running: bool = False
+        self._task: Optional[asyncio.Task] = None
+        self.last_values: dict[str, Any] = {}
+        self.switch_state: Optional[bool] = None
+        self.ping_interval: int = 30
+
+        self.on_update = on_update
+        self._session = session
+        self.signal_update = f"{device_id}_update"
+
+    async def connect(self) -> None:
+        """Connect to the device and start listening."""
+        if self._running:
+            return
+        # Prepare session
+        if self._session is None:
+            self._session = ClientSession()
+
+        _LOGGER.debug("Attempting WebSocket connection to %s", self.url)
+        try:
+            ws = await self._session.ws_connect(
+                self.url,
+                timeout=ClientWSTimeout(ws_close=10),
+                heartbeat=self.ping_interval,
+                autoping=True,
+            )
+        except Exception as err:
+            _LOGGER.error(
+                "Initial WebSocket connect failed for %s: %s", self.device_id, err
+            )
+            self._running = False
+            raise
+        else:
+            self._running = True
+            self.ws = ws
+            self.connected = True
+            _LOGGER.info("WebSocket connected to device %s", self.device_id)
+            self._task = asyncio.create_task(self._run_loop())
+
+    async def _run_loop(self) -> None:
+        """Run the WebSocket listen and auto-reconnect loop."""
+        first_try = True
+        while self._running:
+            try:
+                if not first_try:
+                    _LOGGER.info("Reconnecting to device %s", self.device_id)
+                    ws = await self._session.ws_connect(
+                        self.url,
+                        timeout=ClientWSTimeout(ws_close=10),
+                        heartbeat=self.ping_interval,
+                        autoping=True,
+                    )
+                    self.ws = ws
+                    self.connected = True
+                    _LOGGER.info("WebSocket reconnected to device %s", self.device_id)
+                else:
+                    first_try = False
+
+                assert self.ws is not None
+                async for msg in self.ws:
+                    if msg.type == WSMsgType.TEXT:
+                        try:
+                            data = msg.json()
+                        except ValueError as e:
+                            _LOGGER.error("Received invalid JSON: %s, data: %s", e, msg.data)
+                            continue
+                        _LOGGER.debug("Received message: %s", data)
+                        self._handle_message(data)
+                    elif msg.type == WSMsgType.ERROR:
+                        assert self.ws is not None
+                        _LOGGER.error(
+                            "WebSocket error for %s: %s",
+                            self.device_id,
+                            self.ws.exception(),
+                        )
+                        break
+                    elif msg.type in (WSMsgType.CLOSED, WSMsgType.CLOSING):
+                        _LOGGER.warning(
+                            "WebSocket connection closed for %s", self.device_id
+                        )
+                        break
+            except Exception as err:
+                _LOGGER.error(
+                    "WebSocket connection failed for %s: %s", self.device_id, err
+                )
+            # Clean up and maybe reconnect
+            self.connected = False
+            if self.ws is not None:
+                try:
+                    await self.ws.close()
+                except Exception:
+                    pass
+                finally:
+                    self.ws = None
+
+            if self._running:
+                await asyncio.sleep(5)
+                continue
+
+    def _handle_message(self, data: dict[str, Any]) -> None:
+        """Process incoming message from WebSocket."""
+        func = (data.get("FunctionCode") or data.get("function") or data.get("func"))
+        if isinstance(func, str):
+            func = func.lower()
+
+        if func == "notifystatus":
+            payload = data.get("Payload") or {}
+            _LOGGER.debug("Received payload: %s", payload)
+            for k, v in payload.items():
+                key = k.replace("_1", "")
+                if key == REXENSE_SWITCH_ONOFF['name']:
+                    self.switch_state = v not in ("0", False)
+                    _LOGGER.debug("Update switch state: %s", self.switch_state)
+                else:
+                    _LOGGER.debug("Update sensor %s: %s", key, v)
+                    self.last_values[key] = v
+            # Trigger update callback
+            if self.on_update:
+                try:
+                    self.on_update()
+                except Exception as e:
+                    _LOGGER.error("Error in on_update callback: %s", e)
+        else:
+            _LOGGER.debug("Unhandled function %s: %s", func, data)
+
+    async def async_set_switch(self, on: bool) -> None:
+        """Send ON/OFF command to device via WebSocket."""
+        if not self.connected or self.ws is None:
+            raise RuntimeError("WebSocket is not connected.")
+        control = "On" if on else "Off"
+        payload = {
+            "FunctionCode": "InvokeCmd",
+            "Payload": {control: {}},
+        }
+        try:
+            await self.ws.send_json(payload)
+        except Exception as err:
+            _LOGGER.error("Failed to send switch command: %s", err)
+            raise
+
+    async def disconnect(self) -> None:
+        """Disconnect and stop the WebSocket client."""
+        _LOGGER.info("Disconnecting WebSocket for device %s", self.device_id)
+        self._running = False
+        if self.ws is not None:
+            await self.ws.close()
+        if self._task:
+            await self._task
+        self.ws = None
+        self.connected = False
+
+    async def disconnect(self) -> None:
+        """Disconnect and stop the WebSocket client."""
+        _LOGGER.info("Disconnecting WebSocket for device %s", self.device_id)
+        self._running = False
+        if self.ws is not None:
+            await self.ws.close()
+        if self._task:
+            await self._task
+        self.ws = None
+        self.connected = False

aiorexense-0.1.1/tests/test_api.py

@@ -0,0 +1,53 @@
+
+import pytest
+from aiohttp import ClientError
+import aiorexense.api as api
+
+class DummyResponse:
+    def __init__(self, status, data):
+        self.status = status
+        self._data = data
+
+    async def json(self):
+        return self._data
+
+class DummySession:
+    def __init__(self, response):
+        self._response = response
+
+    async def get(self, url, json):
+        return self._response
+
+@pytest.mark.asyncio
+async def test_get_basic_info_success():
+    data = {
+        "FunctionCode": "ReportBasicInfo",
+        "DeviceId": "dev123",
+        "Payload": {
+            "ModelId": "modelX",
+            "SwBuildId": "build1",
+            "FeatureMap": [{"feat":1}],
+        }
+    }
+    resp = DummyResponse(200, data)
+    session = DummySession(resp)
+    device_id, model, sw_build_id, feature_map = await api.get_basic_info("host", 80, session)
+    assert device_id == "dev123"
+    assert model == "modelX"
+    assert sw_build_id == "build1"
+    assert feature_map == [{"feat":1}]
+
+@pytest.mark.asyncio
+async def test_get_basic_info_http_error():
+    resp = DummyResponse(404, {})
+    session = DummySession(resp)
+    with pytest.raises(ClientError):
+        await api.get_basic_info("host", 80, session)
+
+@pytest.mark.asyncio
+async def test_get_basic_info_invalid_format():
+    data = {"FunctionCode": "WrongCode", "Payload": {}}
+    resp = DummyResponse(200, data)
+    session = DummySession(resp)
+    with pytest.raises(ClientError):
+        await api.get_basic_info("host", 80, session)

aiorexense-0.1.1/tests/test_const.py

@@ -0,0 +1,13 @@
+
+import aiorexense.const as const
+
+def test_constants():
+    assert const.DEFAULT_PORT == 80
+    assert const.API_VERSION == "1.0"
+    assert const.VENDOR_CODE == "Rexense"
+    assert const.FUNCTION_GET_BASIC_INFO == "GetBasicInfo"
+    assert isinstance(const.REXENSE_SENSOR_CURRENT, dict)
+    # test some sensor fields
+    assert const.REXENSE_SENSOR_CURRENT["name"] == "Current"
+    assert const.REXENSE_SENSOR_TEMPERATURE["unit"] == "°C"
+    assert const.REXENSE_SWITCH_ONOFF["name"] == "PowerSwitch"

aiorexense-0.1.1/tests/test_ws_client.py

@@ -0,0 +1,85 @@
+
+import pytest
+import asyncio
+from aiorexense.ws_client import RexenseWebsocketClient
+
+from aiorexense.const import REXENSE_SWITCH_ONOFF
+
+def test_handle_message_notify_status():
+    updates = []
+    def on_update():
+        updates.append(True)
+
+    client = RexenseWebsocketClient(
+        device_id="dev123",
+        model="modelX",
+        url="ws://example",
+        sw_build_id="build1",
+        feature_map=[],
+        on_update=on_update,
+    )
+    # simulate payload
+    payload = {
+        REXENSE_SWITCH_ONOFF['name']: "1",
+        "TestSensor": 123,
+    }
+    data = {"FunctionCode": "NotifyStatus", "Payload": payload}
+    client._handle_message(data)
+
+    assert client.switch_state is True
+    assert client.last_values.get("TestSensor") == 123
+    assert updates == [True]
+
+def test_handle_message_unhandled(caplog):
+    client = RexenseWebsocketClient("dev", "model", "url", "sw", [])
+    caplog.set_level("DEBUG")
+    client._handle_message({"FunctionCode": "UnknownFunc", "Payload": {}})
+    assert "Unhandled function" in caplog.text
+
+@pytest.mark.asyncio
+async def test_async_set_switch_not_connected():
+    client = RexenseWebsocketClient("dev", "model", "url", "sw", [])
+    client.connected = False
+    client.ws = None
+    with pytest.raises(RuntimeError):
+        await client.async_set_switch(True)
+
+@pytest.mark.asyncio
+async def test_async_set_switch_success():
+    sent = []
+    class DummyWS:
+        async def send_json(self, payload):
+            sent.append(payload)
+
+    client = RexenseWebsocketClient("dev", "model", "url", "sw", [])
+    client.connected = True
+    client.ws = DummyWS()
+
+    await client.async_set_switch(False)
+    assert sent[-1] == {"FunctionCode": "InvokeCmd", "Payload": {"Off": {}}}
+
+    await client.async_set_switch(True)
+    assert sent[-1] == {"FunctionCode": "InvokeCmd", "Payload": {"On": {}}}
+
+@pytest.mark.asyncio
+async def test_disconnect(monkeypatch):
+    client = RexenseWebsocketClient("dev", "model", "url", "sw", [])
+    # Attach dummy ws and task
+    class DummyWS:
+        async def close(self):
+            pass
+
+    client.ws = DummyWS()
+    client.connected = True
+    client._running = True
+
+    # Create and cancel a dummy task
+    async def dummy_task():
+        await asyncio.sleep(0)
+    task = asyncio.create_task(dummy_task())
+    client._task = task
+
+    await client.disconnect()
+
+    assert client.ws is None
+    assert client.connected is False