hyxi-cloud-api 1.3.0__tar.gz → 1.3.2__tar.gz

{hyxi_cloud_api-1.3.0/src/hyxi_cloud_api.egg-info → hyxi_cloud_api-1.3.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: hyxi-cloud-api
-Version: 1.3.0
+Version: 1.3.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.3.0 → hyxi_cloud_api-1.3.2}/pyproject.toml

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

{hyxi_cloud_api-1.3.0 → hyxi_cloud_api-1.3.2}/src/hyxi_cloud_api/__init__.py

@@ -5,5 +5,5 @@ from .api import HyxiApiClient
 # Module-level alias so callers can do: from hyxi_cloud_api import VPP_ACTIVE_MODES
 VPP_ACTIVE_MODES: frozenset[str] = HyxiApiClient.VPP_ACTIVE_MODES
 
-__version__ = "1.3.0"
+__version__ = "1.3.2"
 __all__ = ["VPP_ACTIVE_MODES", "HyxiApiClient"]

{hyxi_cloud_api-1.3.0 → hyxi_cloud_api-1.3.2}/src/hyxi_cloud_api/api.py

@@ -587,6 +587,16 @@ def _compute_load_metrics(m_raw: dict, derived: dict[str, float]) -> None:
             + _get_f("ph3Loadp", m_raw)
         )
 
+    if "loadPower" in m_raw or "totalPac" in m_raw:
+        derived["load_power_w"] = _get_f("loadPower", m_raw)
+
+        if (
+            derived["load_power_w"] == 0.0
+            and m_raw.get("status") == 1
+            and "totalPac" in m_raw
+        ):
+            derived["load_power_w"] = _get_f("totalPac", m_raw)
+
 
 def _compute_grid_metrics(m_raw: dict, derived: dict[str, float]) -> None:
     """Calculate grid import/export metrics."""
@@ -602,7 +612,7 @@ def _compute_battery_metrics(
     """Calculate battery charge/discharge metrics."""
     bat_p_dc = _get_f("batP", m_raw)
     pbat = _get_f("pbat", m_raw)
-    device_type_str = str(device_type or "").upper()
+    device_type_str = str(device_type or "")
 
     if "batP" in m_raw or "pbat" in m_raw or device_type_str in ("EMS", "15", "16"):
         # ALL_IN_ONE: prefer pbat — batP can have an inverted sign convention,
@@ -667,6 +677,157 @@ def _compute_derived_metrics(m_raw: dict, device_type: str = "") -> dict:
     return derived
 
 
+def _flatten_nested_push_device(device: dict) -> dict:  # pylint: disable=too-many-statements
+    """Flatten a nested push device payload into the flat layout expected by the SDK."""
+    flat: dict = {}
+
+    # 1. record
+    if "record" in device and isinstance(device["record"], dict):
+        rec = device["record"]
+        if "deviceSn" in rec:
+            flat["deviceSn"] = rec["deviceSn"]
+        if "collectTime" in rec:
+            try:
+                flat["collectTime"] = float(rec["collectTime"]) / 1000.0
+            except ValueError, TypeError:
+                flat["collectTime"] = rec["collectTime"]
+        if "parentSn" in rec:
+            flat["parentSn"] = rec["parentSn"]
+        if "deviceState" in rec:
+            flat["deviceState"] = rec["deviceState"]
+
+    # Copy root device keys that might already be flat
+    for k in ("deviceSn", "collectTime", "reportTimestamp"):
+        if k in device and device[k] is not None:
+            val = device[k]
+            if k == "collectTime":
+                try:
+                    num_val = float(val)
+                    if num_val > 10000000000:
+                        flat[k] = num_val / 1000.0
+                    else:
+                        flat[k] = val
+                except ValueError, TypeError:
+                    flat[k] = val
+            else:
+                flat[k] = val
+
+    # 2. system
+    if "system" in device and isinstance(device["system"], dict):
+        sys_info = device["system"]
+        if "workMode" in sys_info:
+            flat["workMode"] = sys_info["workMode"]
+
+    # 3. ac
+    if "ac" in device and isinstance(device["ac"], dict):
+        ac_info = device["ac"]
+        if "frequencyHz" in ac_info:
+            flat["f"] = ac_info["frequencyHz"]
+        if "powerW" in ac_info:
+            flat["acP"] = ac_info["powerW"]
+        if "energyKwh" in ac_info:
+            flat["acE"] = ac_info["energyKwh"]
+
+    # 4. pv
+    if "pv" in device and isinstance(device["pv"], dict):
+        pv_info = device["pv"]
+        if "totalPowerW" in pv_info:
+            flat["ppv"] = pv_info["totalPowerW"]
+        for i in range(1, 5):
+            pv_key = f"pv{i}"
+            if pv_key in pv_info and isinstance(pv_info[pv_key], dict):
+                pvi = pv_info[pv_key]
+                if "voltageV" in pvi:
+                    flat[f"pv{i}v"] = pvi["voltageV"]
+                if "currentA" in pvi:
+                    flat[f"pv{i}i"] = pvi["currentA"]
+                if "powerW" in pvi:
+                    flat[f"pv{i}p"] = pvi["powerW"]
+
+    # 5. battery
+    if "battery" in device and isinstance(device["battery"], dict):
+        bat = device["battery"]
+        if "serialNumber" in bat:
+            flat["batSn"] = bat["serialNumber"]
+        if "capacityKwh" in bat:
+            flat["batCap"] = bat["capacityKwh"]
+        if "socPercent" in bat:
+            flat["batSoc"] = bat["socPercent"]
+        if "sohPercent" in bat:
+            flat["batSoh"] = bat["sohPercent"]
+        if "powerW" in bat:
+            flat["batP"] = bat["powerW"]
+        if "pbatW" in bat:
+            flat["pbat"] = bat["pbatW"]
+        if "voltageV" in bat:
+            flat["batV"] = bat["voltageV"]
+        if "currentA" in bat:
+            flat["batI"] = bat["currentA"]
+        if "chargeEnergyKwh" in bat:
+            flat["batCharge"] = bat["chargeEnergyKwh"]
+        if "dischargeEnergyKwh" in bat:
+            flat["batDisCharge"] = bat["dischargeEnergyKwh"]
+
+        # battery.temperature
+        if "temperature" in bat and isinstance(bat["temperature"], dict):
+            btemp = bat["temperature"]
+            if "chargeTempC" in btemp:
+                flat["batTch"] = btemp["chargeTempC"]
+            if "cellLowTempC" in btemp:
+                flat["batTcl"] = btemp["cellLowTempC"]
+
+        # battery.limits
+        if "limits" in bat and isinstance(bat["limits"], dict):
+            blim = bat["limits"]
+            if "maxChargePowerW" in blim:
+                flat["maxChargePower"] = blim["maxChargePowerW"]
+            if "maxDischargePowerW" in blim:
+                flat["maxDischargePower"] = blim["maxDischargePowerW"]
+
+        # battery.cellVoltage
+        if "cellVoltage" in bat and isinstance(bat["cellVoltage"], dict):
+            bvol = bat["cellVoltage"]
+            if "cellVoltageLowV" in bvol:
+                flat["batVcl"] = bvol["cellVoltageLowV"]
+            if "cellVoltageHighV" in bvol:
+                flat["batVch"] = bvol["cellVoltageHighV"]
+
+    # 6. dcBus
+    if "dcBus" in device and isinstance(device["dcBus"], dict):
+        dbus = device["dcBus"]
+        if "vbus" in dbus:
+            flat["vbus"] = dbus["vbus"]
+
+    # 7. temperatures
+    if "temperatures" in device and isinstance(device["temperatures"], dict):
+        temps = device["temperatures"]
+        if "inverterTempC" in temps:
+            flat["tinv"] = temps["inverterTempC"]
+
+    # 8. phases
+    if "phases" in device and isinstance(device["phases"], dict):
+        phs = device["phases"]
+        for i in range(1, 4):
+            ph_key = f"ph{i}"
+            if ph_key in phs and isinstance(phs[ph_key], dict):
+                phi = phs[ph_key]
+                if "voltageV" in phi:
+                    flat[f"ph{i}v"] = phi["voltageV"]
+                if "currentA" in phi:
+                    flat[f"ph{i}i"] = phi["currentA"]
+                if "powerW" in phi:
+                    flat[f"ph{i}p"] = phi["powerW"]
+                if "epsPowerW" in phi:
+                    flat[f"ph{i}Loadp"] = phi["epsPowerW"]
+
+    # Copy any other keys at the root that aren't dictionaries
+    for k, v in device.items():
+        if k not in flat and not isinstance(v, dict):
+            flat[k] = v
+
+    return flat
+
+
 @functools.lru_cache(maxsize=1024)
 def _mask_id(value: str) -> str:
     """Mask an identifier (SN, plant ID, etc.) for logs.
@@ -1042,7 +1203,7 @@ class HyxiApiClient:  # pylint: disable=too-many-instance-attributes
             "ratedFrequency": i_raw.get("ratedFrequency"),
         }
 
-        device_type_code = entry.get("device_type_code", "").upper()
+        device_type_code = entry.get("device_type_code", "")
         if _BATTERY_DEVICE_REGEX.search(device_type_code):
             base_info.update(HyxiApiClient._extract_battery_info(i_raw))
 
@@ -1426,12 +1587,13 @@ class HyxiApiClient:  # pylint: disable=too-many-instance-attributes
         """Helper to concurrently process plants to gather metrics and alarms."""
         device_fetch_tasks, alarm_fetch_tasks = self._build_plant_tasks(state)
 
-        await HyxiApiClient._execute_device_tasks(device_fetch_tasks)
-
-        plant_alarms = await self._fetch_and_process_alarms(
-            alarm_fetch_tasks,
-            state,
-            allow_back_discovery=allow_back_discovery,
+        _, plant_alarms = await asyncio.gather(
+            HyxiApiClient._execute_device_tasks(device_fetch_tasks),
+            self._fetch_and_process_alarms(
+                alarm_fetch_tasks,
+                state,
+                allow_back_discovery=allow_back_discovery,
+            ),
         )
 
         # 3. Concurrent Metrics
@@ -1457,8 +1619,7 @@ class HyxiApiClient:  # pylint: disable=too-many-instance-attributes
         state.metric_tasks.append(self._fetch_all_for_device(sn, entry, dev_type))
 
         # 🚀 DEEP BACK-DISCOVERY: If this is a parent, search for ITS children too!
-        dev_type_upper = dev_type.upper()
-        if _PARENT_DEVICE_REGEX.search(dev_type_upper):
+        if _PARENT_DEVICE_REGEX.search(dev_type):
             sub_device_tasks.append(self._fetch_sub_devices(sn, state))
 
     async def _process_alarms_and_back_discovery(
@@ -1593,7 +1754,7 @@ class HyxiApiClient:  # pylint: disable=too-many-instance-attributes
     @staticmethod
     def _build_device_entry(sn, device_data, now):
         """Build a standardized device entry dictionary from raw API data."""
-        dev_type = str(device_data.get("deviceType") or "UNKNOWN")
+        dev_type = str(device_data.get("deviceType") or "UNKNOWN").upper()
         friendly_name = (
             DEVICE_TYPE_MAP.get(dev_type) or dev_type.replace("_", " ").title()
         )
@@ -1628,6 +1789,10 @@ class HyxiApiClient:  # pylint: disable=too-many-instance-attributes
         Values are strings per the developer docs ('' for idle/self-consumption,
         a wattage like '100' for 1063/1064, '0'/'1' for switches).
         """
+        if not control_map:
+            _LOGGER.warning("set_device_control called with empty settings")
+            return {}
+
         await self._ensure_authenticated(self.ControlError)
 
         path = "/api/device/v2/control"
@@ -1922,7 +2087,11 @@ class HyxiApiClient:  # pylint: disable=too-many-instance-attributes
         """Calculate derived metrics (grid import/export, bat charging/discharging, etc.) from raw metrics."""
         return _compute_derived_metrics(m_raw, device_type)
 
-    def process_push_data(self, payload: dict) -> dict[str, dict[str, Any]]:
+    def process_push_data(
+        self,
+        payload: dict,
+        existing_metrics: dict[str, dict[str, Any]] | None = None,
+    ) -> dict[str, dict[str, Any]]:
         """Process real-time push data from HYXI Cloud.
 
         Parses the flat push payload, matches it to the discovery cache,
@@ -1954,6 +2123,8 @@ class HyxiApiClient:  # pylint: disable=too-many-instance-attributes
             if not isinstance(device, dict):
                 continue
 
+            device = _flatten_nested_push_device(device)
+
             sn = device.get("deviceSn")
             if not sn:
                 continue
@@ -1966,6 +2137,10 @@ class HyxiApiClient:  # pylint: disable=too-many-instance-attributes
                     continue
                 raw_metrics[k] = v
 
+            # Retrieve info from discovery cache
+            device_info = self._discovery_cache.get("device_info", {}).get(sn, {})
+            device_type = str(device_info.get("device_type_code") or "")
+
             # Handle collectTime / reportTimestamp to resolve last_seen
             last_seen = now_utc
             collect_time = device.get("collectTime")
@@ -1986,25 +2161,29 @@ class HyxiApiClient:  # pylint: disable=too-many-instance-attributes
                 except ValueError, TypeError:
                     pass
 
-            raw_metrics["last_seen"] = last_seen
-
-            # Retrieve info from discovery cache
-            device_info = self._discovery_cache.get("device_info", {}).get(sn, {})
-            device_type = str(device_info.get("device_type_code") or "").upper()
-
             # Filter collector metrics
             if device_type == "COLLECTOR":
-                metrics = _filter_collector_metrics(raw_metrics)
+                metrics_to_update = _filter_collector_metrics(raw_metrics)
             else:
-                metrics = raw_metrics.copy()
-
-            # Compute derived metrics
-            derived = _compute_derived_metrics(metrics, device_type)
-            metrics.update(derived)
+                metrics_to_update = raw_metrics.copy()
+            # Merge with existing metrics if provided, ignoring None/null values
+            merged_metrics = {}
+            if existing_metrics and sn in existing_metrics:
+                # Copy existing to avoid mutating caller's dictionary directly
+                merged_metrics = dict(existing_metrics[sn])
+
+            for k, v in metrics_to_update.items():
+                if v is not None:
+                    merged_metrics[k] = v
+            merged_metrics["last_seen"] = last_seen
+
+            # Compute derived metrics on the full merged dataset
+            derived = _compute_derived_metrics(merged_metrics, device_type)
+            merged_metrics.update(derived)
 
             results[sn] = {
                 "sn": sn,
-                "metrics": metrics,
+                "metrics": merged_metrics,
                 "model": device_info.get("model", "Unknown"),
                 "device_type_code": device_info.get("device_type_code", "Unknown"),
             }

{hyxi_cloud_api-1.3.0 → hyxi_cloud_api-1.3.2/src/hyxi_cloud_api.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: hyxi-cloud-api
-Version: 1.3.0
+Version: 1.3.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.3.0 → hyxi_cloud_api-1.3.2}/src/hyxi_cloud_api.egg-info/SOURCES.txt

@@ -8,12 +8,16 @@ src/hyxi_cloud_api.egg-info/SOURCES.txt
 src/hyxi_cloud_api.egg-info/dependency_links.txt
 src/hyxi_cloud_api.egg-info/requires.txt
 src/hyxi_cloud_api.egg-info/top_level.txt
+tests/test_additional_coverage.py
 tests/test_alarm_push.py
 tests/test_all_in_one.py
 tests/test_api.py
 tests/test_build_plant_tasks.py
 tests/test_caching.py
+tests/test_compute_battery_metrics.py
 tests/test_compute_derived_metrics.py
+tests/test_compute_grid_metrics.py
+tests/test_compute_load_metrics.py
 tests/test_device_control.py
 tests/test_device_entry.py
 tests/test_devices_errors.py
@@ -46,4 +50,6 @@ tests/test_sanitize_list.py
 tests/test_security_fix.py
 tests/test_subscriptions.py
 tests/test_token_errors.py
-tests/test_token_handling.py
+tests/test_token_handling.py
+tests/test_validate_post_rate_ms.py
+tests/test_validate_subscription_device_sns.py

hyxi_cloud_api-1.3.2/tests/test_additional_coverage.py

@@ -0,0 +1,194 @@
+import logging
+from unittest.mock import AsyncMock, MagicMock
+
+import pytest
+
+from src.hyxi_cloud_api.api import FetchState, HyxiApiClient
+
+
+@pytest.mark.asyncio
+async def test_fetch_sub_devices_coverage(caplog):
+    """Test _fetch_sub_devices debug logging, duplicates, and exceptions."""
+    caplog.set_level(logging.DEBUG)
+    mock_session = MagicMock()
+    api = HyxiApiClient("ak", "sk", "https://api.com", mock_session)
+
+    # 1. Test successful sub-device discovery with debug logging
+    state = FetchState(now="2026-06-02T08:00:00")
+    state.discovered_sns.add("DUPLICATE_SN")
+
+    children_data = [
+        {"deviceSn": "NEW_SN", "deviceType": "INVERTER"},
+        {
+            "deviceSn": "DUPLICATE_SN",
+            "deviceType": "INVERTER",
+        },  # should be skipped (duplicate)
+        {"deviceSn": "", "deviceType": "INVERTER"},  # should be skipped (missing SN)
+    ]
+    api._fetch_sub_device_list = AsyncMock(return_value=children_data)
+    api._fetch_all_for_device = AsyncMock()
+
+    await api._fetch_sub_devices("PARENT_SN", state)
+
+    # Verify debug log was hit (line 1243)
+    # PARENT_SN is masked to ca7b0e8c
+    assert "HYXI Found 3 sub-devices under ca7b0e8c" in caplog.text
+    # Verify duplicate/empty check worked (line 1253)
+    assert api._fetch_all_for_device.call_count == 1
+    api._fetch_all_for_device.assert_called_once_with(
+        "NEW_SN",
+        {
+            "sn": "NEW_SN",
+            "device_name": "Inverter NEW_SN",
+            "model": "Inverter",
+            "device_type_code": "INVERTER",
+            "sw_version": None,
+            "hw_version": None,
+            "metrics": {"last_seen": "2026-06-02T08:00:00"},
+        },
+        "INVERTER",
+    )
+
+    # 2. Test exception logging in _fetch_sub_devices (lines 1265-1266)
+    caplog.clear()
+    api._fetch_sub_device_list = AsyncMock(side_effect=Exception("Database failure"))
+    await api._fetch_sub_devices("PARENT_SN", state)
+    # PARENT_SN is masked to ca7b0e8c
+    assert "Error fetching sub-devices for ca7b0e8c: Database failure" in caplog.text
+
+
+@pytest.mark.asyncio
+async def test_fetch_alarms_for_plant_coverage(caplog):
+    """Test _fetch_alarms_for_plant rejection and alarm name mapping."""
+    caplog.set_level(logging.ERROR)
+    mock_session = MagicMock()
+    api = HyxiApiClient("ak", "sk", "https://api.com", mock_session)
+
+    # 1. Rejection logging (lines 1281-1286)
+    api._request = AsyncMock(
+        return_value=(200, {"success": False, "msg": "Limit exceeded"})
+    )
+    res = await api._fetch_alarms_for_plant("PLANT_123")
+    assert res == []
+    # PLANT_123 is masked to b7a0873d
+    assert "HYXI API Alarm Fetch Rejected for Plant b7a0873d" in caplog.text
+
+    # 2. Alarm Name Mapping (line 1295)
+    api._request = AsyncMock(
+        return_value=(
+            200,
+            {
+                "success": True,
+                "data": {
+                    "pageData": [
+                        {
+                            "alarmCode": "704",
+                            "alarmState": "1",
+                        }  # "704" is mapped in ALARM_CODE_MAP
+                    ]
+                },
+            },
+        )
+    )
+    res = await api._fetch_alarms_for_plant("PLANT_123")
+    assert len(res) == 1
+    assert (
+        res[0]["alarmName"] == "The ambient temperature is too high"
+    )  # ALARM_CODE_MAP["704"]
+
+
+@pytest.mark.asyncio
+async def test_execute_fetch_all_errors():
+    """Test _execute_fetch_all authentication fail paths (lines 1530, 1532)."""
+    mock_session = MagicMock()
+    api = HyxiApiClient("ak", "sk", "https://api.com", mock_session)
+
+    # 1. auth_failed path (line 1530)
+    api._refresh_token = AsyncMock(return_value="auth_failed")
+    res = await api._execute_fetch_all()
+    assert res == "auth_failed"
+
+    # 2. False token status path (line 1532)
+    api._refresh_token = AsyncMock(return_value=False)
+    res = await api._execute_fetch_all()
+    assert res is None
+
+
+@pytest.mark.asyncio
+async def test_execute_fetch_full_discovery_error():
+    """Test _execute_fetch_full_discovery returns None if fetch_plants fails (line 1588)."""
+    mock_session = MagicMock()
+    api = HyxiApiClient("ak", "sk", "https://api.com", mock_session)
+    state = FetchState(now="now")
+
+    api._fetch_plants = AsyncMock(return_value=None)
+    res = await api._execute_fetch_full_discovery(state, allow_back_discovery=False)
+    assert res is None
+
+
+@pytest.mark.asyncio
+async def test_alter_alarm_token_errors():
+    """Test alter_alarm raises ControlError on token failure (line 1911)."""
+    mock_session = MagicMock()
+    api = HyxiApiClient("ak", "sk", "https://api.com", mock_session)
+
+    # 1. auth_failed
+    api._refresh_token = AsyncMock(return_value="auth_failed")
+    with pytest.raises(HyxiApiClient.ControlError, match="Authentication failed"):
+        await api.alter_alarm([123])
+
+    # 2. False status (line 1911)
+    api._refresh_token = AsyncMock(return_value=False)
+    with pytest.raises(HyxiApiClient.ControlError, match="Could not obtain API token"):
+        await api.alter_alarm([123])
+
+
+def test_compute_derived_metrics_classmethod():
+    """Test compute_derived_metrics proxy call (line 1937)."""
+    res = HyxiApiClient.compute_derived_metrics({"gridP": 100}, "INVERTER")
+    assert isinstance(res, dict)
+    assert "grid_import" in res
+
+
+def test_process_push_data_edge_cases(caplog):
+    """Test process_push_data ignores invalid items and dates (lines 1973, 1977, 2001-2002, 2008-2009)."""
+    caplog.set_level(logging.WARNING)
+    mock_session = MagicMock()
+    api = HyxiApiClient("ak", "sk", "https://api.com", mock_session)
+
+    # dataList contains invalid elements (non-dict, missing SN, invalid dates)
+    payload = {
+        "dataList": [
+            123,  # not a dict (line 1973)
+            {"reportTimestamp": 1712728593000},  # missing SN (line 1977)
+            {
+                "deviceSn": "SN123",
+                "collectTime": "invalid_date_type",  # invalid date type (line 2001-2002)
+                "reportTimestamp": "invalid_ts_type",  # invalid timestamp type (line 2008-2009)
+            },
+        ]
+    }
+
+    res = api.process_push_data(payload)
+    assert "SN123" in res
+    assert res["SN123"]["metrics"]["last_seen"].startswith("2")  # starts with year 202x
+
+
+def test_process_alarm_push_data_edge_cases(caplog):
+    """Test process_alarm_push_data handles invalid elements (lines 2078, 2082)."""
+    caplog.set_level(logging.WARNING)
+    mock_session = MagicMock()
+    api = HyxiApiClient("ak", "sk", "https://api.com", mock_session)
+
+    payload = {
+        "dataList": [
+            123,  # not a dict (line 2078)
+            {"alarmCode": "12"},  # missing SN (line 2082)
+            {"deviceSn": "SN123", "alarmCode": "12", "alarmState": "1"},  # valid
+        ]
+    }
+
+    res = api.process_alarm_push_data(payload)
+    assert "SN123" in res
+    assert len(res["SN123"]) == 1
+    assert res["SN123"][0]["alarmCode"] == "12"

hyxi_cloud_api-1.3.2/tests/test_compute_battery_metrics.py

@@ -0,0 +1,78 @@
+"""Tests for the _compute_battery_metrics helper function."""
+
+from src.hyxi_cloud_api.api import _compute_battery_metrics
+
+
+def test_compute_battery_metrics_all_in_one():
+    """Test ALL_IN_ONE device specific logic where pbat is preferred."""
+    derived: dict[str, float] = {}
+    m_raw = {"batP": 500.0, "pbat": -450.0}
+    _compute_battery_metrics(m_raw, derived, "ALL_IN_ONE")
+    assert derived["bat_charging"] == 450.0
+    assert derived["bat_discharging"] == 0.0
+    assert derived["bat_power_dc"] == 500.0
+
+
+def test_compute_battery_metrics_all_in_one_fallback_to_bat_p():
+    """Test ALL_IN_ONE fallback logic when pbat is zero."""
+    derived: dict[str, float] = {}
+    m_raw = {"batP": -500.0, "pbat": 0.0}
+    _compute_battery_metrics(m_raw, derived, "ALL_IN_ONE")
+    assert derived["bat_charging"] == 500.0
+    assert derived["bat_discharging"] == 0.0
+    assert derived["bat_power_dc"] == -500.0
+
+
+def test_compute_battery_metrics_other_devices():
+    """Test standard device logic where batP is preferred."""
+    derived: dict[str, float] = {}
+    m_raw = {"batP": 600.0, "pbat": 550.0}
+    _compute_battery_metrics(m_raw, derived, "OTHER")
+    assert derived["bat_charging"] == 0.0
+    assert derived["bat_discharging"] == 600.0
+    assert derived["bat_power_dc"] == 600.0
+
+
+def test_compute_battery_metrics_other_devices_fallback_to_pbat():
+    """Test standard device fallback logic when batP is zero."""
+    derived: dict[str, float] = {}
+    m_raw = {"batP": 0.0, "pbat": 400.0}
+    _compute_battery_metrics(m_raw, derived, "OTHER")
+    assert derived["bat_charging"] == 0.0
+    assert derived["bat_discharging"] == 400.0
+    assert derived["bat_power_dc"] == 0.0
+
+
+def test_compute_battery_metrics_ems_device_type_no_keys():
+    """Test EMS device type logic handles empty input keys."""
+    derived: dict[str, float] = {}
+    m_raw: dict = {}
+    _compute_battery_metrics(m_raw, derived, "EMS")
+    assert derived["bat_charging"] == 0.0
+    assert derived["bat_discharging"] == 0.0
+    assert derived["bat_power_dc"] == 0.0
+
+
+def test_compute_battery_metrics_totals():
+    """Test handling of total charging and discharging statistics."""
+    derived: dict[str, float] = {}
+    m_raw = {"batCharge": 12.5, "batDisCharge": 45.6}
+    _compute_battery_metrics(m_raw, derived, "OTHER")
+    assert derived["bat_charge_total"] == 12.5
+    assert derived["bat_discharge_total"] == 45.6
+
+
+def test_compute_battery_metrics_empty():
+    """Test graceful handling of empty inputs."""
+    derived: dict[str, float] = {}
+    _compute_battery_metrics({}, derived, "")
+    assert not derived
+
+
+def test_compute_battery_metrics_none_device_type():
+    """Test graceful handling of missing device_type."""
+    derived: dict[str, float] = {}
+    m_raw = {"batP": -100.0}
+    _compute_battery_metrics(m_raw, derived, None)  # type: ignore
+    assert derived["bat_charging"] == 100.0
+    assert derived["bat_power_dc"] == -100.0