hyxi-cloud-api 1.2.0__tar.gz → 1.2.2__tar.gz

{hyxi_cloud_api-1.2.0/src/hyxi_cloud_api.egg-info → hyxi_cloud_api-1.2.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: hyxi-cloud-api
-Version: 1.2.0
+Version: 1.2.2
 Summary: An async API client for HYXi Cloud.
 Author-email: Veldkornet <Veldkornet@users.noreply.github.com>
 Classifier: Programming Language :: Python :: 3

{hyxi_cloud_api-1.2.0 → hyxi_cloud_api-1.2.2}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "hyxi-cloud-api"
-version = "1.2.0"
+version = "1.2.2"
 authors = [
   { name="Veldkornet", email="Veldkornet@users.noreply.github.com" },
 ]

{hyxi_cloud_api-1.2.0 → hyxi_cloud_api-1.2.2}/src/hyxi_cloud_api/__init__.py

@@ -2,5 +2,5 @@
 
 from .api import HyxiApiClient
 
-__version__ = "1.2.0"
+__version__ = "1.2.2"
 __all__ = ["HyxiApiClient"]

{hyxi_cloud_api-1.2.0 → hyxi_cloud_api-1.2.2}/src/hyxi_cloud_api/api.py

@@ -9,6 +9,7 @@ from __future__ import annotations
 
 import asyncio
 import base64
+import functools
 import hashlib
 import hmac
 import logging
@@ -42,7 +43,15 @@ class FetchState:
 
 
 _LOGGER = logging.getLogger(__name__)
-_battery_device_types = ("INVERTER", "ESS", "HALO", "1", "15")
+_battery_device_types = (
+    "INVERTER",
+    "ESS",
+    "HALO",
+    "1",
+    "15",
+    "16",
+    "MICRO_STORAGE_ALL_IN_ONE",
+)
 _BATTERY_DEVICE_REGEX = re.compile("|".join(_battery_device_types))
 _parent_device_types = ("COLLECTOR", "DMU", "INVERTER", "ALL_IN_ONE")
 _PARENT_DEVICE_REGEX = re.compile("|".join(_parent_device_types))
@@ -501,6 +510,7 @@ DEVICE_TYPE_MAP = {
     "ENERGY_STORAGE_BATTERY": "Battery",
     "ALL_IN_ONE": "all-in-one machine",
     "AC_BATTERY": "AC Battery",
+    "MICRO_STORAGE_ALL_IN_ONE": "Micro ESS",
     # Official Numeric IDs (as seen in getSubDevicePage)
     "1": "Hybrid Inverter",
     "2": "Grid-Connected Inverter",
@@ -621,9 +631,19 @@ def _compute_derived_metrics(m_raw: dict, device_type: str = "") -> dict:
         ppv_total = _get_f("ppv", m_raw)
         derived["pv1p"] = round(max(ppv_total - derived["pv2p"], 0), 2)
 
+    # 5. Fallback mappings for Micro ESS
+    # Derive standard Solar Power (ppv) from Micro ESS pvPower if ppv is missing
+    if "pvPower" in m_raw and "ppv" not in m_raw:
+        derived["ppv"] = _get_f("pvPower", m_raw)
+
+    # Derive standard Grid Frequency (f) from Micro ESS gridF if f is missing
+    if "gridF" in m_raw and "f" not in m_raw:
+        derived["f"] = _get_f("gridF", m_raw)
+
     return derived
 
 
+@functools.lru_cache(maxsize=1024)
 def _mask_id(value: str) -> str:
     """Mask an identifier (SN, plant ID, etc.) for logs.
 
@@ -884,7 +904,13 @@ class HyxiApiClient:  # pylint: disable=too-many-instance-attributes
                 else:
                     entry["metrics"].update(m_raw)
 
-                if "gridP" in m_raw or "pbat" in m_raw or "batP" in m_raw:
+                if (
+                    "gridP" in m_raw
+                    or "pbat" in m_raw
+                    or "batP" in m_raw
+                    or "pvPower" in m_raw
+                    or "gridF" in m_raw
+                ):
                     entry["metrics"].update(
                         _compute_derived_metrics(
                             m_raw, entry.get("device_type_code", "")
@@ -899,17 +925,6 @@ class HyxiApiClient:  # pylint: disable=too-many-instance-attributes
         except Exception as e:
             _LOGGER.error("Error fetching metrics for %s: %s", _mask_id(sn), e)
 
-    async def _fetch_ems_basic_data(self, ems_sn, entry):
-        """Helper to fetch and merge EMS-specific basic details."""
-        _LOGGER.debug("HYXI Probing EMS telemetry for %s...", _mask_id(ems_sn))
-        m_raw = await self.query_ems_basic_details(ems_sn)
-        if m_raw:
-            entry["metrics"].update(m_raw)
-        else:
-            _LOGGER.debug(
-                "HYXI EMS telemetry probe returned no data for %s", _mask_id(ems_sn)
-            )
-
     async def query_ems_basic_details(self, ems_sn):
         """Acquire basic data for Energy Storage Systems (ESS)."""
         path = "/api/ems/v1/queryBasicDetails"
@@ -958,10 +973,11 @@ class HyxiApiClient:  # pylint: disable=too-many-instance-attributes
             "_sw_ver_sys": sw_ver,
             "signalIntensity": i_raw.get("signalIntensity"),
             "signalVal": i_raw.get("signalVal"),
-            "wifiVer": i_raw.get("wifiVer"),
+            "wifiVer": i_raw.get("wifiVer") or i_raw.get("swVerWifi"),
             "comMode": i_raw.get("comMode"),
             "swVerMaster": i_raw.get("swVerMaster"),
             "swVerSlave": i_raw.get("swVerSlave"),
+            "ratedFrequency": i_raw.get("ratedFrequency"),
         }
 
         device_type_code = entry.get("device_type_code", "").upper()
@@ -1011,14 +1027,25 @@ class HyxiApiClient:  # pylint: disable=too-many-instance-attributes
         tasks = [asyncio.create_task(self._fetch_device_info(sn, entry))]
         is_comm_unit = dev_type in ("COLLECTOR", "DMU", "3")
 
+        ems_task = None
         if not is_comm_unit:
             tasks.append(asyncio.create_task(self._fetch_device_metrics(sn, entry)))
-            tasks.append(asyncio.create_task(self._fetch_ems_basic_data(sn, entry)))
+            ems_task = asyncio.create_task(self.query_ems_basic_details(sn))
+            tasks.append(ems_task)
 
         # Wait for them to finish
         if tasks:
             await asyncio.gather(*tasks)
 
+        if ems_task:
+            m_raw = ems_task.result()
+            if m_raw:
+                entry["metrics"].update(m_raw)
+            else:
+                _LOGGER.debug(
+                    "HYXI EMS telemetry probe returned no data for %s", _mask_id(sn)
+                )
+
         return sn, entry
 
     async def _fetch_device_list_for_plant(self, plant_id: str) -> list[dict] | None:
@@ -1049,9 +1076,9 @@ class HyxiApiClient:  # pylint: disable=too-many-instance-attributes
 
         if _LOGGER.isEnabledFor(logging.DEBUG):
             _LOGGER.debug(
-                "HYXI Discovered Devices for Plant %s: %s",
+                "HYXI Discovered Devices for Plant %s: [%s]",
                 _mask_id(plant_id),
-                [_mask_id(d.get("deviceSn", "UNKNOWN")) for d in devices],
+                ", ".join(_mask_id(d.get("deviceSn", "UNKNOWN")) for d in devices),
             )
         return devices
 
@@ -1131,10 +1158,10 @@ class HyxiApiClient:  # pylint: disable=too-many-instance-attributes
 
             if _LOGGER.isEnabledFor(logging.DEBUG):
                 _LOGGER.debug(
-                    "HYXI Found %s sub-devices under %s: %s",
+                    "HYXI Found %s sub-devices under %s: [%s]",
                     len(children),
                     _mask_id(parent_sn),
-                    [_mask_id(c.get("deviceSn", "UNKNOWN")) for c in children],
+                    ", ".join(_mask_id(c.get("deviceSn", "UNKNOWN")) for c in children),
                 )
 
             for c in children:
@@ -1197,6 +1224,7 @@ class HyxiApiClient:  # pylint: disable=too-many-instance-attributes
         """Fetches data with built-in retry logic and returns attempt count."""
 
         for attempt in range(1, MAX_RETRIES + 1):
+            err: aiohttp.ClientError | TimeoutError | None = None
             try:
                 data = await self._execute_fetch_all(
                     allow_back_discovery=allow_back_discovery,
@@ -1209,9 +1237,12 @@ class HyxiApiClient:  # pylint: disable=too-many-instance-attributes
                     return {"data": data, "attempts": attempt}
 
                 # If we get here, data was None (soft failure). Trigger a retry manually.
-                raise aiohttp.ClientError("Fetch returned None, triggering retry.")
+                err = aiohttp.ClientError("Fetch returned None, triggering retry.")
 
-            except (aiohttp.ClientError, TimeoutError) as err:
+            except (aiohttp.ClientError, TimeoutError) as e:
+                err = e
+
+            if err is not None:
                 if attempt < MAX_RETRIES:
                     wait_time = attempt * RETRY_DELAY
                     _LOGGER.debug(
@@ -1258,8 +1289,8 @@ class HyxiApiClient:  # pylint: disable=too-many-instance-attributes
         # 👇 Log the discovered plants
         if _LOGGER.isEnabledFor(logging.DEBUG):
             _LOGGER.debug(
-                "HYXI Discovered Plants: %s",
-                [_mask_id(p.get("plantId", "UNKNOWN")) for p in plants],
+                "HYXI Discovered Plants: [%s]",
+                ", ".join(_mask_id(p.get("plantId", "UNKNOWN")) for p in plants),
             )
 
         return plants
@@ -1650,3 +1681,38 @@ class HyxiApiClient:  # pylint: disable=too-many-instance-attributes
         For **MICRO_INVERTER** devices.
         """
         return await self.set_device_control(device_sn, {3013: "1"})
+
+    # ── Alarm Controls ───────────────────────────────────────────────────
+
+    async def alter_alarm(self, alarm_ids: list[int]) -> dict:
+        """Process/Acknowledge alarm information.
+
+        Endpoint: POST /api/alarm/v1/alterAlarm
+        Body: {"ids": [id1, id2, ...], "state": 1}
+        """
+        token_status = await self._refresh_token()
+        if token_status == "auth_failed":
+            raise self.ControlError("Authentication failed")
+        if not token_status:
+            raise self.ControlError("Could not obtain API token")
+
+        path = "/api/alarm/v1/alterAlarm"
+        body = {
+            "ids": alarm_ids,
+            "state": 1,
+        }
+        _LOGGER.debug(
+            "HYXI ALTER_ALARM request for ids %s: %s",
+            alarm_ids,
+            body,
+        )
+        _, res = await self._request("POST", path, json=body)
+        if res is None or not res.get("success"):
+            code = res.get("code", "unknown") if res else "no_response"
+            msg = res.get("msg", "") if res else ""
+            raise self.ControlError(f"alarm alteration failed (code={code}): {msg}")
+        _LOGGER.debug(
+            "HYXI ALTER_ALARM response: success=%s",
+            res.get("success"),
+        )
+        return res

{hyxi_cloud_api-1.2.0 → hyxi_cloud_api-1.2.2/src/hyxi_cloud_api.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: hyxi-cloud-api
-Version: 1.2.0
+Version: 1.2.2
 Summary: An async API client for HYXi Cloud.
 Author-email: Veldkornet <Veldkornet@users.noreply.github.com>
 Classifier: Programming Language :: Python :: 3

{hyxi_cloud_api-1.2.0 → hyxi_cloud_api-1.2.2}/tests/test_api.py

@@ -1,5 +1,6 @@
 import sys
-from unittest.mock import MagicMock
+import time
+from unittest.mock import AsyncMock, MagicMock
 
 if "aiohttp" not in sys.modules or not hasattr(sys.modules["aiohttp"], "ClientError"):
     m = MagicMock()
@@ -19,7 +20,7 @@ mock_aiohttp = sys.modules["aiohttp"]
 """Tests for the HYXI Cloud API client."""
 
 import logging
-from unittest.mock import AsyncMock, MagicMock
+from unittest.mock import MagicMock
 
 import aiohttp
 import pytest
@@ -49,6 +50,20 @@ def test_api_initialization():
     assert api.token is None
 
 
+@pytest.mark.asyncio
+async def test_request_unsupported_method():
+    """Test that _request raises ValueError for unsupported HTTP methods."""
+    fake_session = MagicMock()
+    api = HyxiApiClient(
+        access_key="fake_access_key",
+        secret_key="fake_secret_key",
+        base_url="https://fake-hyxi-url.com",
+        session=fake_session,
+    )
+    with pytest.raises(ValueError, match="Unsupported HTTP method: PUT"):
+        await api._request("PUT", "/some/path")
+
+
 # --- TEST 2: The Retry Logic Wrapper ---
 @pytest.mark.asyncio
 async def test_get_all_device_data_success():
@@ -234,17 +249,19 @@ async def test_query_ems_basic_details_success():
 
 @pytest.mark.asyncio
 async def test_fetch_ems_basic_data_success(caplog):
-    """Test _fetch_ems_basic_data when basic details are returned."""
+    """Test _fetch_all_for_device when basic details are returned."""
     caplog.set_level(logging.DEBUG)
 
     mock_session = MagicMock()
     api = HyxiApiClient("ak", "sk", "https://api.com", mock_session)
     api.query_ems_basic_details = AsyncMock(return_value={"new_metric": "new_value"})
+    api._fetch_device_info = AsyncMock()
+    api._fetch_device_metrics = AsyncMock()
 
     ems_sn = "10602251600016"
     entry = {"device_type_code": "EMS", "metrics": {"existing_metric": "value"}}
 
-    await api._fetch_ems_basic_data(ems_sn, entry)
+    await api._fetch_all_for_device(ems_sn, entry, "INVERTER")
 
     # Assert query_ems_basic_details was called
     api.query_ems_basic_details.assert_called_once_with(ems_sn)
@@ -255,17 +272,19 @@ async def test_fetch_ems_basic_data_success(caplog):
 
 @pytest.mark.asyncio
 async def test_fetch_ems_basic_data_no_data(caplog):
-    """Test _fetch_ems_basic_data when no basic details are returned."""
+    """Test _fetch_all_for_device when no basic details are returned."""
     caplog.set_level(logging.DEBUG)
 
     mock_session = MagicMock()
     api = HyxiApiClient("ak", "sk", "https://api.com", mock_session)
     api.query_ems_basic_details = AsyncMock(return_value={})
+    api._fetch_device_info = AsyncMock()
+    api._fetch_device_metrics = AsyncMock()
 
     ems_sn = "EMS123"
     entry = {"device_type_code": "EMS", "metrics": {"existing_metric": "value"}}
 
-    await api._fetch_ems_basic_data(ems_sn, entry)
+    await api._fetch_all_for_device(ems_sn, entry, "INVERTER")
 
     # Assert query_ems_basic_details was called
     api.query_ems_basic_details.assert_called_once_with("EMS123")
@@ -427,18 +446,15 @@ async def test_fetch_alarms_for_plant_sanitization(caplog):
 
 @pytest.mark.asyncio
 async def test_fetch_all_for_device_collector():
-    """Test _fetch_all_for_device when dev_type is COLLECTOR."""
-    api = HyxiApiClient("key", "secret", "url", session=MagicMock())
+    """Test _fetch_all_for_device when dev_type is COLLECTOR.
 
-    async def dummy_info(*args, **kwargs):
-        pass
-
-    async def dummy_metrics(*args, **kwargs):
-        pass
+    Collector/DMU units skip metrics and EMS probing — only device info is fetched.
+    """
+    api = HyxiApiClient("key", "secret", "url", session=MagicMock())
 
-    api._fetch_device_info = MagicMock(side_effect=dummy_info)
-    api._fetch_device_metrics = MagicMock(side_effect=dummy_metrics)
-    api._fetch_ems_basic_data = AsyncMock()
+    api._fetch_device_info = AsyncMock()
+    api._fetch_device_metrics = AsyncMock()
+    api.query_ems_basic_details = AsyncMock()
 
     sn = "SN_123"
     entry = {"initial": "state"}
@@ -451,25 +467,27 @@ async def test_fetch_all_for_device_collector():
 
     api._fetch_device_info.assert_called_once_with(sn, entry)
     api._fetch_device_metrics.assert_not_called()
+    api.query_ems_basic_details.assert_not_called()
 
 
 @pytest.mark.asyncio
 async def test_fetch_all_for_device_non_collector():
-    """Test _fetch_all_for_device when dev_type is not COLLECTOR."""
-    api = HyxiApiClient("key", "secret", "url", session=MagicMock())
+    """Test _fetch_all_for_device when dev_type is not COLLECTOR.
 
-    async def dummy_info(*args, **kwargs):
-        pass
-
-    async def dummy_metrics(*args, **kwargs):
-        pass
+    Non-collector devices (e.g. INVERTER) trigger device info, metrics, and EMS
+    telemetry probing concurrently. query_ems_basic_details must be mocked to
+    prevent unawaited coroutine RuntimeWarnings from the real HTTP path.
+    """
+    api = HyxiApiClient("key", "secret", "url", session=MagicMock())
 
-    api._fetch_device_info = MagicMock(side_effect=dummy_info)
-    api._fetch_device_metrics = MagicMock(side_effect=dummy_metrics)
-    api._fetch_ems_basic_data = AsyncMock()
+    api._fetch_device_info = AsyncMock()
+    api._fetch_device_metrics = AsyncMock()
+    # Must mock query_ems_basic_details: _fetch_all_for_device fires it as an
+    # asyncio.create_task. Without this mock the real coroutine leaks unawaited.
+    api.query_ems_basic_details = AsyncMock(return_value={})
 
     sn = "SN_456"
-    entry = {"initial": "state2"}
+    entry = {"metrics": {}, "initial": "state2"}
     dev_type = "INVERTER"
 
     result_sn, result_entry = await api._fetch_all_for_device(sn, entry, dev_type)
@@ -479,6 +497,7 @@ async def test_fetch_all_for_device_non_collector():
 
     api._fetch_device_info.assert_called_once_with(sn, entry)
     api._fetch_device_metrics.assert_called_once_with(sn, entry)
+    api.query_ems_basic_details.assert_called_once_with(sn)
 
 
 # --- TEST 6: Empty Data Response (The "Halo ESS" Scenario) ---
@@ -551,3 +570,98 @@ async def test_fetch_alarms_for_plant_error(caplog):
 
     log_text = caplog.text
     assert "Error fetching alarms for plant ef797c81: Connection reset" in log_text
+
+
+@pytest.mark.asyncio
+async def test_execute_fetch_all_force_discovery():
+    """Verify that _execute_fetch_all respects the force_discovery flag to bypass cache."""
+    api = HyxiApiClient("ak", "sk", "https://api.com", MagicMock())
+
+    # Bypass token validation
+    api._refresh_token = AsyncMock(return_value=True)
+
+    # Mock cache state to be valid
+    api._discovery_cache["plants"] = [{"plantId": "plant_1"}]
+    api._discovery_cache_time = time.time()
+    api._discovery_cache_ttl = 3600
+
+    # Mock internal methods
+    api._execute_fetch_cached = AsyncMock(return_value="cached_result")
+    api._execute_fetch_full_discovery = AsyncMock(return_value="full_discovery_result")
+
+    # Test 1: force_discovery=True should bypass cache and call full discovery
+    result = await api._execute_fetch_all(force_discovery=True)
+
+    assert result == "full_discovery_result"
+    api._execute_fetch_full_discovery.assert_called_once()
+    api._execute_fetch_cached.assert_not_called()
+
+    # Reset mocks
+    api._execute_fetch_full_discovery.reset_mock()
+    api._execute_fetch_cached.reset_mock()
+
+    # Test 2: force_discovery=False should use cache
+    result = await api._execute_fetch_all(force_discovery=False)
+
+    assert result == "cached_result"
+    api._execute_fetch_cached.assert_called_once()
+    api._execute_fetch_full_discovery.assert_not_called()
+
+
+@pytest.mark.asyncio
+async def test_execute_fetch_all_force_discovery_integration():
+    """Verify that force_discovery=True bypasses cache and integrates with full discovery."""
+    from unittest.mock import patch  # pylint: disable=import-outside-toplevel
+
+    api = HyxiApiClient("ak", "sk", "https://api.com", MagicMock())
+
+    # Bypass token validation
+    api._refresh_token = AsyncMock(return_value=True)
+
+    # Mock cache state to be valid to test bypass
+    api._discovery_cache["plants"] = [{"plantId": "plant_1"}]
+    api._discovery_cache_time = time.time()
+    api._discovery_cache_ttl = 3600
+
+    # Mock the HTTP layer to return valid JSON responses for a full discovery flow
+    plant_resp = {"success": True, "data": {"list": [{"plantId": "plant_1"}]}}
+    device_resp = {
+        "success": True,
+        "data": {"deviceList": [{"deviceSn": "device_1", "deviceType": "INVERTER"}]},
+    }
+    sub_dev_resp = {"success": True, "data": {"childDevice": []}}
+    alarms_resp = {"success": True, "data": {"pageData": []}}
+    info_resp = {"success": True, "data": {"swVerSys": "v1.0", "hwVer": "v1.0"}}
+    metrics_resp = {"success": True, "data": [{"dataKey": "gridP", "dataValue": "100"}]}
+
+    with patch.object(api, "_request") as mock_req:
+        mock_req.side_effect = [
+            (200, plant_resp),
+            (200, device_resp),
+            (200, sub_dev_resp),
+            (200, alarms_resp),
+            (200, info_resp),
+            (200, metrics_resp),
+            (200, {}),  # EMS Probe
+        ]
+
+        # Use wraps to spy on internal methods while preserving their original logic
+        with (
+            patch.object(
+                api,
+                "_execute_fetch_full_discovery",
+                wraps=api._execute_fetch_full_discovery,
+            ) as mock_full,
+            patch.object(
+                api, "_execute_fetch_cached", wraps=api._execute_fetch_cached
+            ) as mock_cached,
+        ):
+            result = await api._execute_fetch_all(force_discovery=True)
+
+            # Assert that the full discovery method was called and cached was not
+            mock_full.assert_called_once()
+            mock_cached.assert_not_called()
+
+            # Ensure we successfully parsed the data, meaning full discovery worked
+            assert "device_1" in result
+            assert result["device_1"]["sw_version"] == "v1.0"

{hyxi_cloud_api-1.2.0 → hyxi_cloud_api-1.2.2}/tests/test_caching.py

@@ -6,6 +6,7 @@ from unittest.mock import AsyncMock, patch
 import pytest
 
 from hyxi_cloud_api import HyxiApiClient
+from hyxi_cloud_api.api import FetchState
 
 
 @pytest.mark.asyncio
@@ -91,3 +92,67 @@ async def test_discovery_caching_logic():
         ]
         await client.get_all_device_data(force_discovery=True)
         assert mock_req.call_count == 7
+
+
+@pytest.mark.asyncio
+async def test_execute_fetch_cached_no_device_info():
+    """Verify _execute_fetch_cached handles missing device_info without errors."""
+    session = AsyncMock()
+    client = HyxiApiClient("key", "secret", "http://api.com", session)
+
+    # Empty cache
+    client._discovery_cache = {
+        "plants": [{"plantId": "P1"}],
+        "device_info": None,
+    }
+
+    state = FetchState(now="2023-01-01T00:00:00Z")
+
+    with (
+        patch.object(client, "_build_plant_tasks", return_value=([], [])) as mock_build,
+        patch.object(
+            client, "_fetch_and_process_alarms", return_value={}
+        ) as mock_alarms,
+        patch.object(
+            client, "_execute_metric_tasks", new_callable=AsyncMock
+        ) as mock_exec,
+    ):
+        results = await client._execute_fetch_cached(state, allow_back_discovery=True)
+
+        # Verify it runs without error and executes the next steps
+        assert results == {}
+        assert len(state.metric_tasks) == 0
+        mock_build.assert_called_once()
+        mock_alarms.assert_called_once()
+        mock_exec.assert_called_once()
+
+
+@pytest.mark.asyncio
+async def test_execute_fetch_cached_empty_cache():
+    """Verify _execute_fetch_cached handles fully empty cache without errors."""
+    session = AsyncMock()
+    client = HyxiApiClient("key", "secret", "http://api.com", session)
+
+    # Fully empty cache
+    client._discovery_cache = {}
+
+    state = FetchState(now="2023-01-01T00:00:00Z")
+
+    with (
+        patch.object(client, "_build_plant_tasks", return_value=([], [])) as mock_build,
+        patch.object(
+            client, "_fetch_and_process_alarms", return_value={}
+        ) as mock_alarms,
+        patch.object(
+            client, "_execute_metric_tasks", new_callable=AsyncMock
+        ) as mock_exec,
+    ):
+        results = await client._execute_fetch_cached(state, allow_back_discovery=True)
+
+        # Verify it runs without error and executes the next steps
+        assert results == {}
+        assert not state.plants
+        assert len(state.metric_tasks) == 0
+        mock_build.assert_called_once()
+        mock_alarms.assert_called_once()
+        mock_exec.assert_called_once()

{hyxi_cloud_api-1.2.0 → hyxi_cloud_api-1.2.2}/tests/test_compute_derived_metrics.py

@@ -1,5 +1,7 @@
 """Tests for the _compute_derived_metrics helper function in api.py."""
 
+# pylint: disable=too-many-public-methods
+
 from src.hyxi_cloud_api.api import _compute_derived_metrics
 
 
@@ -89,6 +91,55 @@ class TestComputeDerivedMetrics:
         result = _compute_derived_metrics({})
         assert not result
 
+    def test_missing_pv_power_derived(self):
+        """Test PV power is derived when missing but voltage and current are present."""
+        data = {"pv1v": 100.0, "pv1i": 5.0}
+        result = _compute_derived_metrics(data)
+        assert "pv1p" in result
+        assert result["pv1p"] == 500.0
+
+    def test_provided_pv_power_takes_precedence(self):
+        """Test provided PV power takes precedence over derived power."""
+        data = {"pv1v": 100.0, "pv1i": 5.0, "pv1p": 600.0}
+        result = _compute_derived_metrics(data)
+        assert "pv1p" in result
+        assert result["pv1p"] == 600.0
+
+    def test_partial_pv_data(self):
+        """Test PV power derivation with partial data (e.g. only voltage)."""
+        data = {"pv1v": 100.0}
+        result = _compute_derived_metrics(data)
+        assert "pv1p" in result
+        assert result["pv1p"] == 0.0
+
+    def test_pv_power_recalculated_when_zero(self):
+        """Test PV power recalculation if provided value is falsy (e.g. 0.0) but voltage/current exist."""
+        data = {"pv1v": 100.0, "pv1i": 5.0, "pv1p": 0.0}
+        result = _compute_derived_metrics(data)
+        assert "pv1p" in result
+        assert result["pv1p"] == 500.0
+
+    def test_pv_power_calculation_rounding(self):
+        """Test the rounding logic when calculating PV power from voltage and current."""
+        data = {"pv1v": 100.33, "pv1i": 5.12}
+        result = _compute_derived_metrics(data)
+        assert "pv1p" in result
+        assert result["pv1p"] == 513.69  # 100.33 * 5.12 = 513.6896, rounded to 513.69
+
+    def test_pv1p_derived_from_ppv_and_pv2p(self):
+        """Test the ALL_IN_ONE fallback logic where pv1p is derived from ppv - pv2p."""
+        data = {"ppv": 1500.0, "pv2v": 100.0, "pv2i": 5.0}  # pv2p will be 500.0
+        result = _compute_derived_metrics(data)
+        assert "pv1p" in result
+        assert result["pv1p"] == 1000.0
+
+    def test_pv1p_derived_from_ppv_and_pv2p_zero_floor(self):
+        """Test that the derived pv1p does not go below zero."""
+        data = {"ppv": 400.0, "pv2v": 100.0, "pv2i": 5.0}  # pv2p will be 500.0
+        result = _compute_derived_metrics(data)
+        assert "pv1p" in result
+        assert result["pv1p"] == 0.0
+
     def test_selective_pv_strings(self):
         """Test that only PV strings present in input are present in output."""
         data = {"pv1v": 100, "pv1i": 5}  # PV1 only
@@ -107,3 +158,15 @@ class TestComputeDerivedMetrics:
         result = _compute_derived_metrics({"ph1Loadp": 100.0})
         assert "home_load" in result
         assert result["home_load"] == 100.0
+
+    def test_micro_ess_pv_power_fallback(self):
+        """Test that ppv is derived from pvPower when ppv is missing (Micro ESS fallback)."""
+        data = {"pvPower": 1200.5}
+        result = _compute_derived_metrics(data)
+        assert result["ppv"] == 1200.5
+
+    def test_micro_ess_grid_frequency_fallback(self):
+        """Test that f is derived from gridF when f is missing (Micro ESS fallback)."""
+        data = {"gridF": 49.98}
+        result = _compute_derived_metrics(data)
+        assert result["f"] == 49.98

{hyxi_cloud_api-1.2.0 → hyxi_cloud_api-1.2.2}/tests/test_device_control.py

@@ -235,10 +235,58 @@ async def test_restart_device():
     """Test restart_device sends controlId 3013 with value '1'."""
     api = HyxiApiClient("ak", "sk", "https://api.com", MagicMock())
     api._refresh_token = AsyncMock(return_value=True)
-    api._request = AsyncMock(return_value=(200, {"success": True}))
+    api._request = MagicMock()
+    # Handle async response for _request
+    async_mock = AsyncMock(return_value=(200, {"success": True}))
+    api._request.side_effect = async_mock
 
     await api.restart_device("SN123")
 
+    api._request.assert_called_once()
     call_kwargs = api._request.call_args
     body = call_kwargs.kwargs.get("json") or call_kwargs[1].get("json")
     assert body["deviceControlMap"]["SN123"]["3013"] == "1"
+
+
+@pytest.mark.asyncio
+async def test_alter_alarm():
+    """Test alter_alarm sends correct POST request payload."""
+    api = HyxiApiClient("ak", "sk", "https://api.com", MagicMock())
+    api._refresh_token = AsyncMock(return_value=True)
+    api._request = AsyncMock(return_value=(200, {"success": True}))
+
+    result = await api.alter_alarm([10086, 10087])
+
+    assert result["success"] is True
+    api._request.assert_called_once()
+    call_args, call_kwargs = api._request.call_args
+    assert call_args[0] == "POST"
+    assert call_args[1] == "/api/alarm/v1/alterAlarm"
+    body = call_kwargs.get("json")
+    assert body == {"ids": [10086, 10087], "state": 1}
+
+
+@pytest.mark.asyncio
+async def test_alter_alarm_auth_failed():
+    """Test alter_alarm raises ControlError when authentication fails."""
+    api = HyxiApiClient("ak", "sk", "https://api.com", MagicMock())
+    api._refresh_token = AsyncMock(return_value="auth_failed")
+
+    with pytest.raises(api.ControlError, match="Authentication failed"):
+        await api.alter_alarm([10086])
+
+
+@pytest.mark.asyncio
+async def test_alter_alarm_api_failure():
+    """Test alter_alarm raises ControlError when API returns success=False."""
+    api = HyxiApiClient("ak", "sk", "https://api.com", MagicMock())
+    api._refresh_token = AsyncMock(return_value=True)
+    api._request = AsyncMock(
+        return_value=(
+            200,
+            {"success": False, "code": "C000002", "msg": "Internal error"},
+        )
+    )
+
+    with pytest.raises(api.ControlError, match="alarm alteration failed"):
+        await api.alter_alarm([10086])

{hyxi_cloud_api-1.2.0 → hyxi_cloud_api-1.2.2}/tests/test_extract_device_info_metadata.py

@@ -87,3 +87,26 @@ def test_extract_device_info_metadata_battery_fallbacks():
     assert base_info["packNum"] == 1
     assert base_info["maxChargePower"] == 30.0
     assert base_info["maxDischargePower"] == 30.0
+
+
+def test_extract_device_info_metadata_micro_ess():
+    """Test extraction of battery-specific metrics and fallbacks for Micro ESS (type 16) devices."""
+    entry = {"metrics": {}, "device_type_code": "16"}
+    i_raw = {
+        "batCap": "15.0",
+        "packNum": "1",
+        "maxChargePower": "700",
+        "maxDischargePower": "700",
+        "swVerWifi": "V01.00.00.01",
+        "ratedFrequency": "50",
+    }
+
+    base_info = HyxiApiClient._extract_device_info_metadata(entry, i_raw)
+
+    assert base_info["batCap"] == 15.0
+    assert base_info["packNum"] == 1
+    assert base_info["maxChargePower"] == 700.0
+    assert base_info["maxDischargePower"] == 700.0
+    assert base_info["wifiVer"] == "V01.00.00.01"
+    assert base_info["ratedFrequency"] == "50"
+    assert "batCap" in entry["metrics"]

{hyxi_cloud_api-1.2.0 → hyxi_cloud_api-1.2.2}/tests/test_metrics_errors.py

@@ -125,39 +125,39 @@ async def test_fetch_device_metrics_api_error(caplog):
 
 @pytest.mark.asyncio
 async def test_fetch_ems_basic_data_no_data(caplog):
-    """Test that _fetch_ems_basic_data handles empty response gracefully."""
+    """Test that _fetch_all_for_device handles empty EMS response gracefully."""
     caplog.set_level(logging.DEBUG)
     mock_session = MagicMock()
     api = HyxiApiClient("ak", "sk", "https://api.com", mock_session)
 
     # Mock query_ems_basic_details to return {} (no data — the actual return contract)
     api.query_ems_basic_details = AsyncMock(return_value={})
+    api._fetch_device_info = AsyncMock()
+    api._fetch_device_metrics = AsyncMock()
 
     entry = {"metrics": {}, "device_type_code": "EMS"}
-    await api._fetch_ems_basic_data("10602251600016", entry)
+    await api._fetch_all_for_device("10602251600016", entry, "INVERTER")
 
     assert "HYXI EMS telemetry probe returned no data for fefbfd75" in caplog.text
-    # Ensure entry was not updated with metrics
+    # Ensure entry was not updated with EMS metrics
     assert not entry["metrics"]
 
 
 @pytest.mark.asyncio
 async def test_fetch_ems_basic_data_error(caplog):
-    """Test that _fetch_ems_basic_data handles errors from query_ems_basic_details."""
+    """Test that _fetch_all_for_device handles errors from query_ems_basic_details."""
     caplog.set_level(logging.DEBUG)
     mock_session = MagicMock()
     api = HyxiApiClient("ak", "sk", "https://api.com", mock_session)
 
-    # Mock _request to raise an Exception to ensure query_ems_basic_details returns {}
     api._request = AsyncMock(side_effect=Exception("EMS data fetch failed"))
+    api._fetch_device_info = AsyncMock()
+    api._fetch_device_metrics = AsyncMock()
 
     entry = {"metrics": {}, "device_type_code": "EMS"}
-    await api._fetch_ems_basic_data("10602251600016", entry)
+    await api._fetch_all_for_device("10602251600016", entry, "INVERTER")
 
-    # Assert entry['metrics'] is unchanged
     assert not entry["metrics"]
-
-    # Assert the correct debug log was emitted from _fetch_ems_basic_data due to empty return
     assert "HYXI EMS telemetry probe returned no data for fefbfd75" in caplog.text
 
 

{hyxi_cloud_api-1.2.0 → hyxi_cloud_api-1.2.2}/tests/test_parser.py

@@ -284,3 +284,41 @@ def test_compute_derived_metrics_zero_edges():
     assert res_neg["grid_export"] == 0.0
     assert res_neg["bat_charging"] == 0.01
     assert res_neg["bat_discharging"] == 0.0
+
+
+@pytest.mark.asyncio
+async def test_api_parsing_micro_ess_fallbacks():
+    """Verify that Micro ESS specific keys (pvPower, gridF) are parsed and correctly trigger derived fallbacks."""
+    fake_json = {
+        "success": True,
+        "data": [
+            {"dataKey": "pvPower", "dataValue": "850.5"},
+            {"dataKey": "gridF", "dataValue": "50.02"},
+        ],
+    }
+
+    mock_response = MagicMock()
+    mock_response.json = AsyncMock(return_value=fake_json)
+    mock_response.raise_for_status = MagicMock()
+
+    mock_session = MagicMock()
+    mock_session.get.return_value.__aenter__.return_value = mock_response
+
+    api = HyxiApiClient(
+        access_key="test_ak",
+        secret_key="test_sk",
+        base_url="https://test.com",
+        session=mock_session,
+    )
+
+    entry = {"metrics": {}, "device_type_code": "15"}  # Micro ESS
+
+    await api._fetch_device_metrics("SN123", entry)
+
+    # Raw metrics must be present
+    assert entry["metrics"]["pvPower"] == "850.5"
+    assert entry["metrics"]["gridF"] == "50.02"
+
+    # Derived fallback metrics must be computed and present
+    assert entry["metrics"]["ppv"] == 850.5
+    assert entry["metrics"]["f"] == 50.02

{hyxi_cloud_api-1.2.0 → hyxi_cloud_api-1.2.2}/tests/test_process_devices_for_plant.py

@@ -34,6 +34,21 @@ def mock_state():
     return FetchState(now="2024-01-01T00:00:00Z")
 
 
+@pytest.mark.asyncio
+async def test_process_devices_for_plant_missing_sn_edge_cases(mock_api, mock_state):
+    """Test with devices having missing, None, or empty string serial numbers."""
+    devices = [
+        {"deviceType": "INVERTER"},
+        {"deviceSn": None, "deviceType": "INVERTER"},
+        {"deviceSn": "", "deviceType": "INVERTER"},
+    ]
+    with patch("asyncio.gather", new_callable=AsyncMock) as mock_gather:
+        await mock_api._process_devices_for_plant(devices, mock_state)
+        mock_gather.assert_not_called()
+        assert len(mock_state.discovered_sns) == 0
+        assert len(mock_state.metric_tasks) == 0
+
+
 @pytest.mark.asyncio
 async def test_process_devices_for_plant_empty(mock_api, mock_state):
     """Test with an empty list of devices."""

{hyxi_cloud_api-1.2.0 → hyxi_cloud_api-1.2.2}/tests/test_token_handling.py

@@ -8,6 +8,7 @@ from unittest.mock import MagicMock
 # Mock aiohttp before importing the client to avoid ModuleNotFoundError in environments without it
 sys.modules["aiohttp"] = MagicMock()
 
+import time
 from unittest.mock import patch
 
 import pytest
@@ -167,6 +168,17 @@ def test_calculate_token_expiration_expiresIn(mock_time, api_client):
     assert expires_at == 1003300.0
 
 
+def test_calculate_token_expiration_missing_expires_in(api_client):
+    """Verify missing expires_in calculates default buffer relative to current time."""
+    # Rationale: Calling `_calculate_token_expiration({})` and ensuring the result is close
+    # to `time.time() + 6600 - 300` would verify this boundary.
+    expected = time.time() + 6600 - 300
+    expires_at = api_client._calculate_token_expiration({})
+
+    # Check if the result is within 1 second of expected to account for execution time
+    assert expires_at == pytest.approx(expected, abs=1.0)
+
+
 @patch("time.time")
 def test_calculate_token_expiration_expires_in(mock_time, api_client):
     """Verify 'expires_in' is used correctly."""