hyxi-cloud-api 1.3.9__tar.gz → 1.4.0__tar.gz

{hyxi_cloud_api-1.3.9/src/hyxi_cloud_api.egg-info → hyxi_cloud_api-1.4.0}/PKG-INFO

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

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

{hyxi_cloud_api-1.3.9 → hyxi_cloud_api-1.4.0}/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.9"
+__version__ = "1.4.0"
 __all__ = ["VPP_ACTIVE_MODES", "HyxiApiClient"]

{hyxi_cloud_api-1.3.9 → hyxi_cloud_api-1.4.0}/src/hyxi_cloud_api/api.py

@@ -25,10 +25,9 @@ from urllib.parse import urlparse
 try:
     from datetime import UTC, datetime
 except ImportError:
-    from datetime import datetime
+    from datetime import datetime, timezone
 
-    # pylint: disable=W0127,E0601
-    UTC = UTC
+    UTC = timezone.utc  # noqa
 
 import aiohttp
 
@@ -45,18 +44,41 @@ class FetchState:
 
 
 _LOGGER = logging.getLogger(__name__)
-_battery_device_types = (
-    "INVERTER",
-    "ESS",
-    "HALO",
-    "1",
-    "15",
-    "16",
-    "MICRO_STORAGE_ALL_IN_ONE",
+_battery_device_types = frozenset(
+    (
+        "INVERTER",
+        "HYBRID_INVERTER",
+        "STRING_INVERTER",
+        "MICRO_INVERTER",
+        "ESS",
+        "HALO",
+        "1",
+        "15",
+        "16",
+        "MICRO_STORAGE_ALL_IN_ONE",
+    )
+)
+_parent_device_types = frozenset(
+    (
+        "COLLECTOR",
+        "DMU",
+        "INVERTER",
+        "HYBRID_INVERTER",
+        "STRING_INVERTER",
+        "MICRO_INVERTER",
+        "ALL_IN_ONE",
+        "MICRO_STORAGE_ALL_IN_ONE",
+    )
+)
+_EMS_DEVICE_TYPES = frozenset(
+    (
+        "EMS",
+        "ENERGY_STORAGE_BATTERY",
+        "MICRO_STORAGE_ALL_IN_ONE",
+        "15",
+        "16",
+    )
 )
-_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))
 _COLLECTOR_FILTER_KEYWORDS = (
     "bat",
     "pv",
@@ -564,9 +586,7 @@ def _get_f(key: str, data_map: dict, mult: float = 1.0) -> float:
         if val is None or val == "":
             return 0.0
         return round(float(val) * mult, 2)
-    except ValueError:
-        return 0.0
-    except TypeError:
+    except ValueError, TypeError:
         return 0.0
 
 
@@ -625,7 +645,7 @@ def _compute_battery_metrics(
     pbat = _get_f("pbat", m_raw)
     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"):
+    if "batP" in m_raw or "pbat" in m_raw or device_type_str in _EMS_DEVICE_TYPES:
         # ALL_IN_ONE: prefer pbat — batP can have an inverted sign convention,
         # while pbat is consistently negative-for-charging / positive-for-discharging.
         # Other devices: prefer batP (DC terminals), fall back to pbat.
@@ -732,6 +752,60 @@ def _compute_derived_metrics(m_raw: dict, device_type: str = "") -> dict:
     return derived
 
 
+def _resolve_push_timestamp(device: dict[str, Any], now_utc: datetime) -> datetime:
+    """Determine the last_seen timestamp from collectTime or reportTimestamp."""
+    collect_time = device.get("collectTime")
+    report_ts = device.get("reportTimestamp")
+
+    if collect_time is not None:
+        try:
+            return datetime.fromtimestamp(float(collect_time), UTC)
+        except ValueError, TypeError, OverflowError, OSError:
+            pass
+
+    if report_ts is not None:
+        try:
+            return datetime.fromtimestamp(float(report_ts) / 1000.0, UTC)
+        except ValueError, TypeError, OverflowError, OSError:
+            pass
+
+    return now_utc
+
+
+def _extract_raw_push_metrics(device: dict[str, Any]) -> dict[str, Any]:
+    """Extract metrics from flat payload dictionary, stripping metadata/routing keys."""
+    raw_metrics: dict[str, Any] = {}
+    for k, v in device.items():
+        if k in _METRICS_EXCLUDED_KEYS:
+            continue
+        raw_metrics[k] = v
+    return raw_metrics
+
+
+def _merge_push_metrics(
+    sn: str,
+    raw_metrics: dict[str, Any],
+    device_type: str,
+    existing_metrics: dict[str, dict[str, Any]] | None,
+) -> dict[str, Any]:
+    """Filter collector metrics and merge with existing metrics."""
+    if device_type == "COLLECTOR":
+        metrics_to_update = _filter_collector_metrics(raw_metrics)
+    else:
+        metrics_to_update = raw_metrics.copy()
+
+    merged_metrics: dict[str, Any] = {}
+    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
+
+    return merged_metrics
+
+
 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 = {}
@@ -751,21 +825,31 @@ def _flatten_nested_push_device(device: dict) -> dict:  # pylint: disable=too-ma
         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":
+    # Map discrepancies between Flat Push payload and Flat Pull payload
+    _key_map = {
+        "gridEin": "totalEnt",
+        "gridEIn": "totalEnt",
+        "gridEout": "totalEpt",
+        "gridEOut": "totalEpt",
+    }
+
+    # Copy all root-level keys that are primitive types (support new flat format)
+    for k, v in device.items():
+        if not isinstance(v, dict) and not isinstance(v, list) and v is not None:
+            # Normalize push metric names to match pull metric names
+            mapped_k = _key_map.get(k, k)
+
+            if mapped_k == "collectTime":
                 try:
-                    num_val = float(val)
+                    num_val = float(v)
                     if num_val > 10000000000:
-                        flat[k] = num_val / 1000.0
+                        flat[mapped_k] = num_val / 1000.0
                     else:
-                        flat[k] = val
+                        flat[mapped_k] = v
                 except ValueError, TypeError:
-                    flat[k] = val
+                    flat[mapped_k] = v
             else:
-                flat[k] = val
+                flat[mapped_k] = v
 
     # 2. system
     if "system" in device and isinstance(device["system"], dict):
@@ -888,14 +972,15 @@ def _flatten_nested_push_device(device: dict) -> dict:  # pylint: disable=too-ma
         if "powerFactor" in grd:
             flat["gridPfd"] = grd["powerFactor"]
         if "energyInKwh" in grd:
-            flat["gridEIn"] = grd["energyInKwh"]
+            flat["totalEnt"] = grd["energyInKwh"]
         if "energyOutKwh" in grd:
-            flat["gridEOut"] = grd["energyOutKwh"]
+            flat["totalEpt"] = grd["energyOutKwh"]
 
     # 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
+            mapped_k = _key_map.get(k, k)
+            flat[mapped_k] = v
 
     return flat
 
@@ -1294,7 +1379,7 @@ class HyxiApiClient:  # pylint: disable=too-many-instance-attributes
         }
 
         device_type_code = entry.get("device_type_code", "")
-        if _BATTERY_DEVICE_REGEX.search(device_type_code):
+        if device_type_code in _battery_device_types:
             base_info.update(HyxiApiClient._extract_battery_info(i_raw))
 
         entry["metrics"].update(base_info)
@@ -1343,8 +1428,11 @@ class HyxiApiClient:  # pylint: disable=too-many-instance-attributes
         ems_task = None
         if not is_comm_unit:
             tasks.append(asyncio.create_task(self._fetch_device_metrics(sn, entry)))
-            ems_task = asyncio.create_task(self.query_ems_basic_details(sn))
-            tasks.append(ems_task)
+
+            actual_type = entry.get("device_type_code", dev_type)
+            if actual_type in _EMS_DEVICE_TYPES:
+                ems_task = asyncio.create_task(self.query_ems_basic_details(sn))
+                tasks.append(ems_task)
 
         # Wait for them to finish
         if tasks:
@@ -1425,7 +1513,7 @@ class HyxiApiClient:  # pylint: disable=too-many-instance-attributes
             state.metric_tasks.append(self._fetch_all_for_device(sn, entry, dev_type))
 
             # 🚀 DEEP DISCOVERY: If this is a Collector, DMU, or Inverter, find its children!
-            if _PARENT_DEVICE_REGEX.search(dev_type):
+            if dev_type in _parent_device_types:
                 _LOGGER.debug(
                     "HYXI Parent Device Found: %s (%s). Probing for sub-devices...",
                     _mask_id(sn),
@@ -1698,7 +1786,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!
-        if _PARENT_DEVICE_REGEX.search(dev_type):
+        if dev_type in _parent_device_types:
             sub_device_tasks.append(self._fetch_sub_devices(sn, state))
 
     async def _process_alarms_and_back_discovery(
@@ -2195,7 +2283,7 @@ class HyxiApiClient:  # pylint: disable=too-many-instance-attributes
             _LOGGER.warning("HYXI Push: dataList is missing or not a list")
             return {}
 
-        now_utc = datetime.now(UTC).isoformat()
+        now_utc = datetime.now(UTC)
         results = {}
 
         for device in data_list:
@@ -2208,53 +2296,17 @@ class HyxiApiClient:  # pylint: disable=too-many-instance-attributes
             if not sn:
                 continue
 
-            # Extract metrics from flat payload dictionary
-            # Strip metadata/routing keys
-            raw_metrics = {}
-            for k, v in device.items():
-                if k in _METRICS_EXCLUDED_KEYS:
-                    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")
-            report_ts = device.get("reportTimestamp")
-
-            if collect_time is not None:
-                try:
-                    last_seen = datetime.fromtimestamp(
-                        float(collect_time), UTC
-                    ).isoformat()
-                except ValueError, TypeError:
-                    pass
-            elif report_ts is not None:
-                try:
-                    last_seen = datetime.fromtimestamp(
-                        float(report_ts) / 1000.0, UTC
-                    ).isoformat()
-                except ValueError, TypeError:
-                    pass
+            raw_metrics = _extract_raw_push_metrics(device)
+            last_seen = _resolve_push_timestamp(device, now_utc)
 
-            # Filter collector metrics
-            if device_type == "COLLECTOR":
-                metrics_to_update = _filter_collector_metrics(raw_metrics)
-            else:
-                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
+            merged_metrics = _merge_push_metrics(
+                sn, raw_metrics, device_type, existing_metrics
+            )
+            merged_metrics["last_seen"] = last_seen.isoformat()
 
             # Compute derived metrics on the full merged dataset
             derived = _compute_derived_metrics(merged_metrics, device_type)

{hyxi_cloud_api-1.3.9 → hyxi_cloud_api-1.4.0/src/hyxi_cloud_api.egg-info}/PKG-INFO

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

@@ -12,6 +12,7 @@ tests/test_additional_coverage.py
 tests/test_alarm_push.py
 tests/test_all_in_one.py
 tests/test_api.py
+tests/test_api_imports.py
 tests/test_build_plant_tasks.py
 tests/test_caching.py
 tests/test_compute_battery_metrics.py
@@ -51,6 +52,7 @@ tests/test_push.py
 tests/test_sanitize_dict.py
 tests/test_sanitize_list.py
 tests/test_security_fix.py
+tests/test_set_log_salt.py
 tests/test_subscriptions.py
 tests/test_token_errors.py
 tests/test_token_handling.py

{hyxi_cloud_api-1.3.9 → hyxi_cloud_api-1.4.0}/tests/test_api.py

@@ -281,7 +281,7 @@ async def test_fetch_ems_basic_data_success(caplog):
     ems_sn = "10602251600016"
     entry = {"device_type_code": "EMS", "metrics": {"existing_metric": "value"}}
 
-    await api._fetch_all_for_device(ems_sn, entry, "INVERTER")
+    await api._fetch_all_for_device(ems_sn, entry, "EMS")
 
     # Assert query_ems_basic_details was called
     api.query_ems_basic_details.assert_called_once_with(ems_sn)
@@ -306,7 +306,7 @@ async def test_fetch_ems_basic_data_no_data(caplog):
     ems_sn = "EMS123"
     entry = {"device_type_code": "EMS", "metrics": {"existing_metric": "value"}}
 
-    await api._fetch_all_for_device(ems_sn, entry, "INVERTER")
+    await api._fetch_all_for_device(ems_sn, entry, "EMS")
 
     # Assert query_ems_basic_details was called
     api.query_ems_basic_details.assert_called_once_with("EMS123")
@@ -497,7 +497,7 @@ async def test_fetch_all_for_device_collector():
 async def test_fetch_all_for_device_non_collector():
     """Test _fetch_all_for_device when dev_type is not COLLECTOR.
 
-    Non-collector devices (e.g. INVERTER) trigger device info, metrics, and EMS
+    Non-collector devices (e.g. INVERTER) trigger device info and metrics
     telemetry probing concurrently. query_ems_basic_details must be mocked to
     prevent unawaited coroutine RuntimeWarnings from the real HTTP path.
     """
@@ -520,7 +520,22 @@ 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)
+    api.query_ems_basic_details.assert_not_called()
+
+    # Reset mocks before verifying EMS-capable device behaviour
+    api._fetch_device_info.reset_mock()
+    api._fetch_device_metrics.reset_mock()
+    api.query_ems_basic_details.reset_mock()
+
+    # EMS-capable non-collector devices should still trigger the EMS probe
+    ems_sn = "EMS123"
+    ems_entry = {"device_type_code": "EMS", "metrics": {"existing_metric": "value"}}
+
+    await api._fetch_all_for_device(ems_sn, ems_entry, "EMS")
+
+    api._fetch_device_info.assert_called_once_with(ems_sn, ems_entry)
+    api._fetch_device_metrics.assert_called_once_with(ems_sn, ems_entry)
+    api.query_ems_basic_details.assert_called_once_with(ems_sn)
 
 
 # --- TEST 6: Empty Data Response (The "Halo ESS" Scenario) ---
@@ -689,3 +704,101 @@ async def test_execute_fetch_all_force_discovery_integration():
             # Ensure we successfully parsed the data, meaning full discovery worked
             assert "device_1" in result
             assert result["device_1"]["sw_version"] == "v1.0"
+
+
+@pytest.mark.asyncio
+async def test_get_all_device_data_unexpected_error():
+    """Test that get_all_device_data propagates unexpected errors."""
+    fake_session = MagicMock()
+    api = HyxiApiClient("ak", "sk", "https://api.com", fake_session)
+
+    # Mock _execute_fetch_all to raise Exception
+    api._execute_fetch_all = AsyncMock(side_effect=Exception("Unexpected Error"))
+
+    with pytest.raises(Exception, match="Unexpected Error"):
+        await api.get_all_device_data()
+
+
+@pytest.mark.asyncio
+async def test_process_push_data_flat_payload():
+    """Test process_push_data correctly handles flat payloads and normalizes grid keys."""
+    fake_session = MagicMock()
+    api = HyxiApiClient("ak", "sk", "https://api.com", fake_session)
+    api.devices_cache = {
+        "SN_FLAT": {"device_sn": "SN_FLAT", "metrics": {"oldMetric": "old"}}
+    }
+
+    # Simulate flat payload from webhook
+    payload = {
+        "dataList": [
+            {
+                "deviceSn": "SN_FLAT",
+                "batP": 123,
+                "gridEin": 456,
+                "gridEout": 789,
+                "reportTimestamp": 1000000000000,
+            }
+        ]
+    }
+    existing = {"SN_FLAT": {"oldMetric": "old"}}
+
+    results = api.process_push_data(payload, existing_metrics=existing)
+    assert "SN_FLAT" in results
+    metrics = results["SN_FLAT"]["metrics"]
+    assert metrics["batP"] == 123
+    assert metrics["oldMetric"] == "old"  # preserves existing
+    assert metrics["totalEnt"] == 456  # validates flat key mapping
+    assert metrics["totalEpt"] == 789
+    assert "last_seen" in metrics
+
+
+@pytest.mark.asyncio
+async def test_process_push_data_nested_payload():
+    """Test process_push_data handles legacy nested payloads and normalizes nested grid keys."""
+    fake_session = MagicMock()
+    api = HyxiApiClient("ak", "sk", "https://api.com", fake_session)
+
+    payload = {
+        "dataList": [
+            {
+                "deviceSn": "SN_NEST",
+                "battery": {"powerW": 123},
+                "grid": {"energyInKwh": 456, "energyOutKwh": 789},
+                "reportTimestamp": 1000000000000,
+            }
+        ]
+    }
+    existing = {"SN_NEST": {"old": "old"}}
+
+    results = api.process_push_data(payload, existing_metrics=existing)
+    assert "SN_NEST" in results
+    metrics = results["SN_NEST"]["metrics"]
+    assert metrics["batP"] == 123
+    assert metrics["totalEnt"] == 456
+    assert metrics["totalEpt"] == 789
+    assert metrics["old"] == "old"
+
+
+@pytest.mark.asyncio
+async def test_process_push_data_timestamp_fallback():
+    """Test process_push_data uses fallback timestamps when invalid."""
+    fake_session = MagicMock()
+    api = HyxiApiClient("ak", "sk", "https://api.com", fake_session)
+
+    payload = {
+        "dataList": [
+            {
+                "deviceSn": "SN_TIME",
+                "batP": 123,
+                "reportTimestamp": "INVALID",
+                "collectTime": "INVALID_TOO",
+            }
+        ]
+    }
+
+    # Should not raise exception
+    results = api.process_push_data(payload, existing_metrics={"SN_TIME": {}})
+    assert "SN_TIME" in results
+    metrics = results["SN_TIME"]["metrics"]
+    assert "last_seen" in metrics
+    assert metrics["batP"] == 123

hyxi_cloud_api-1.4.0/tests/test_api_imports.py

@@ -0,0 +1,33 @@
+"""Tests for import fallbacks in the API client module."""
+
+import builtins
+import sys
+import unittest.mock
+
+
+def test_utc_import_fallback():
+    """Test the ImportError fallback for datetime.UTC at line 27."""
+    original_import = builtins.__import__
+
+    def mocked_import(name, global_vars=None, local_vars=None, fromlist=(), level=0):
+        # Trigger ImportError when trying to import UTC from datetime
+        if name == "datetime" and fromlist and "UTC" in fromlist:
+            raise ImportError("mocked ImportError for UTC")
+        return original_import(name, global_vars, local_vars, fromlist, level)
+
+    original_api = sys.modules.get("hyxi_cloud_api.api")
+    if "hyxi_cloud_api.api" in sys.modules:
+        del sys.modules["hyxi_cloud_api.api"]
+
+    try:
+        with unittest.mock.patch("builtins.__import__", side_effect=mocked_import):
+            from hyxi_cloud_api import api  # pylint: disable=import-outside-toplevel
+
+            assert api.UTC is not None
+            assert api.UTC.tzname(None) == "UTC"
+    finally:
+        # Restore normal module state
+        if "hyxi_cloud_api.api" in sys.modules:
+            del sys.modules["hyxi_cloud_api.api"]
+        if original_api is not None:
+            sys.modules["hyxi_cloud_api.api"] = original_api

{hyxi_cloud_api-1.3.9 → hyxi_cloud_api-1.4.0}/tests/test_caching.py

@@ -53,14 +53,13 @@ async def test_discovery_caching_logic():
         # First call: Full Discovery
         res1 = await client.get_all_device_data()
         assert res1["data"]["S1"]["sw_version"] == "V1"
-        assert mock_req.call_count == 7
+        assert mock_req.call_count == 6
 
         # Second call: Should use cache (Fast Poll)
         # Sequence expected for Fast Poll:
         # 1. Alarms (for Plant)
         # 2. Info (for SN)
         # 3. Metrics (for SN)
-        # 4. EMS Probe
         mock_req.reset_mock()
         mock_req.side_effect = [
             (200, alarms_resp),
@@ -71,7 +70,7 @@ async def test_discovery_caching_logic():
 
         res2 = await client.get_all_device_data()
         assert res2["data"]["S1"]["sw_version"] == "V1"  # Still there from cache
-        assert mock_req.call_count == 4
+        assert mock_req.call_count == 3
 
         # Verify specific URL paths for fast poll
         calls = mock_req.call_args_list
@@ -91,7 +90,7 @@ async def test_discovery_caching_logic():
             (200, {}),  # EMS
         ]
         await client.get_all_device_data(force_discovery=True)
-        assert mock_req.call_count == 7
+        assert mock_req.call_count == 6
 
 
 @pytest.mark.asyncio

{hyxi_cloud_api-1.3.9 → hyxi_cloud_api-1.4.0}/tests/test_devices_errors.py

@@ -1,5 +1,5 @@
 import sys
-from unittest.mock import MagicMock
+from unittest.mock import AsyncMock, MagicMock
 
 if "aiohttp" not in sys.modules or not hasattr(sys.modules["aiohttp"], "ClientError"):
     m = MagicMock()
@@ -96,3 +96,23 @@ async def test_fetch_devices_for_plant_invalid_json(caplog):
     assert "Error fetching devices for plant" in caplog.text
     assert not state.metric_tasks
     assert not state.discovered_sns
+
+
+@pytest.mark.asyncio
+async def test_fetch_devices_for_plant_general_exception(caplog):
+    """Test that _fetch_devices_for_plant handles general exceptions."""
+    caplog.set_level(logging.ERROR)
+    mock_session = MagicMock()
+    api = HyxiApiClient("ak", "sk", "https://api.com", mock_session)
+
+    api._fetch_device_list_for_plant = AsyncMock(
+        side_effect=Exception("Unexpected generic error")
+    )
+
+    state = FetchState(now="2024-01-01")
+    await api._fetch_devices_for_plant("plant123", state)
+
+    assert "Error fetching devices for plant" in caplog.text
+    assert "Unexpected generic error" in caplog.text
+    assert not state.metric_tasks
+    assert not state.discovered_sns

{hyxi_cloud_api-1.3.9 → hyxi_cloud_api-1.4.0}/tests/test_discovery.py

@@ -22,7 +22,7 @@ from unittest.mock import AsyncMock, MagicMock
 
 import pytest
 
-from src.hyxi_cloud_api.api import FetchState, HyxiApiClient
+from hyxi_cloud_api.api import FetchState, HyxiApiClient
 
 
 def _setup_mock_api():
@@ -259,7 +259,7 @@ async def test_fetch_sub_devices_rejected():
 
     with pytest.MonkeyPatch.context() as m:
         mock_logger = MagicMock()
-        m.setattr("src.hyxi_cloud_api.api._LOGGER", mock_logger)
+        m.setattr("hyxi_cloud_api.api._LOGGER", mock_logger)
 
         await api._fetch_sub_devices("BAD_SN", state)
 
@@ -284,7 +284,7 @@ async def test_fetch_sub_devices_exception():
 
     with pytest.MonkeyPatch.context() as m:
         mock_logger = MagicMock()
-        m.setattr("src.hyxi_cloud_api.api._LOGGER", mock_logger)
+        m.setattr("hyxi_cloud_api.api._LOGGER", mock_logger)
 
         await api._fetch_sub_devices("SOME_SN", state)
 
@@ -337,3 +337,28 @@ async def test_back_discovery_sn_validation():
     res = await api.get_all_device_data(allow_back_discovery=True)
     assert "123" not in res["data"]
     api._fetch_all_for_device.assert_not_called()
+
+
+@pytest.mark.asyncio
+async def test_fetch_sub_devices_outer_exception():
+    """Verify that an exception in _fetch_sub_devices is caught and logged."""
+    api = HyxiApiClient("ak", "sk", "https://api.com", MagicMock())
+
+    # Mock _fetch_sub_device_list to raise an exception directly
+    api._fetch_sub_device_list = AsyncMock(side_effect=Exception("Outer Exception"))
+
+    state = FetchState(now="Plant123")
+
+    with pytest.MonkeyPatch.context() as m:
+        mock_logger = MagicMock()
+        m.setattr("hyxi_cloud_api.api._LOGGER", mock_logger)
+
+        await api._fetch_sub_devices("SOME_SN", state)
+
+        assert len(state.metric_tasks) == 0
+        assert len(state.discovered_sns) == 0
+
+        # Verify the logger caught the exception
+        mock_logger.error.assert_called_once()
+        args, _ = mock_logger.error.call_args
+        assert "Error fetching sub-devices for" in args[0]

{hyxi_cloud_api-1.3.9 → hyxi_cloud_api-1.4.0}/tests/test_fetch_plants.py

@@ -23,7 +23,7 @@ from unittest.mock import AsyncMock, MagicMock, patch
 import aiohttp
 import pytest
 
-from src.hyxi_cloud_api.api import HyxiApiClient
+from hyxi_cloud_api.api import HyxiApiClient
 
 
 @pytest.mark.asyncio
@@ -103,7 +103,7 @@ async def test_fetch_plants_empty_list_warning():
         )
     )
 
-    with patch("src.hyxi_cloud_api.api._LOGGER") as mock_logger:
+    with patch("hyxi_cloud_api.api._LOGGER") as mock_logger:
         plants = await api._fetch_plants()
         assert plants == []
         mock_logger.warning.assert_called_once_with(

{hyxi_cloud_api-1.3.9 → hyxi_cloud_api-1.4.0}/tests/test_fetch_sub_device_list.py

@@ -106,3 +106,22 @@ async def test_fetch_sub_device_list_client_error(caplog):
     assert result == []
     assert "Error fetching sub-device list for" in caplog.text
     assert "Connection refused" in caplog.text
+
+
+@pytest.mark.asyncio
+async def test_fetch_sub_device_list_processing_error(caplog):
+    """Verify that a general Exception during processing is caught, logged, and returns an empty list."""
+    caplog.set_level(logging.ERROR)
+    api = HyxiApiClient("ak", "sk", "https://api.com", MagicMock())
+    # Mocking the request to return something that causes an exception (like a list instead of dict)
+    # when attempting to use res_sd.get("success")
+    api._request = AsyncMock(
+        return_value=(200, ["this", "is", "a", "list", "not", "a", "dict"])
+    )
+
+    result = await api._fetch_sub_device_list("parent123")
+
+    assert result == []
+    assert "Error fetching sub-device list for" in caplog.text
+    assert "no attribute 'get'" in caplog.text
+    assert any(record.levelname == "ERROR" for record in caplog.records)

{hyxi_cloud_api-1.3.9 → hyxi_cloud_api-1.4.0}/tests/test_get_f.py

@@ -86,3 +86,13 @@ class TestGetF:
         """Test a condition that triggers a ValueError and returns 0.0."""
         data = {"key": "not-a-number"}
         assert _get_f("key", data) == 0.0
+
+    def test_get_f_explicit_type_error(self):
+        """Test specific condition triggering TypeError at line 567."""
+        data = {"key": []}
+        assert _get_f("key", data) == 0.0
+
+    def test_type_error_mult(self):
+        """Invalid multiplier type should return 0.0 due to TypeError."""
+        data = {"key": 10}
+        assert _get_f("key", data, mult="invalid") == 0.0

{hyxi_cloud_api-1.3.9 → hyxi_cloud_api-1.4.0}/tests/test_metrics_errors.py

@@ -19,7 +19,7 @@ mock_aiohttp = sys.modules["aiohttp"]
 """Tests for exception handling in _fetch_device_metrics."""
 
 import logging
-from unittest.mock import AsyncMock, MagicMock
+from unittest.mock import AsyncMock, MagicMock, patch
 
 import aiohttp
 import pytest
@@ -138,7 +138,7 @@ async def test_fetch_ems_basic_data_no_data(caplog):
     api._fetch_device_metrics = AsyncMock()
 
     entry = {"metrics": {}, "device_type_code": "EMS"}
-    await api._fetch_all_for_device("10602251600016", entry, "INVERTER")
+    await api._fetch_all_for_device("10602251600016", entry, "EMS")
 
     assert "HYXI EMS telemetry probe returned no data for " in caplog.text
     # No EMS data should be merged into metrics.
@@ -158,7 +158,7 @@ async def test_fetch_ems_basic_data_error(caplog):
     api._fetch_device_metrics = AsyncMock()
 
     entry = {"metrics": {}, "device_type_code": "EMS"}
-    await api._fetch_all_for_device("10602251600016", entry, "INVERTER")
+    await api._fetch_all_for_device("10602251600016", entry, "EMS")
 
     # No EMS data should be merged into metrics.
     assert "batSoc" not in entry["metrics"]
@@ -237,3 +237,49 @@ async def test_query_ems_basic_details_malformed_response(caplog):
     assert result == {}
     assert "HYXI EMS Basic Data Request Failed for " in caplog.text
     assert "object has no attribute 'get'" in caplog.text
+
+
+@pytest.mark.asyncio
+async def test_query_ems_basic_details_parse_error(caplog):
+    """Test that query_ems_basic_details handles exceptions during parsing."""
+    caplog.set_level(logging.ERROR)
+    mock_session = MagicMock()
+    api = HyxiApiClient("ak", "sk", "https://api.com", mock_session)
+
+    # Return a response with code 0 but invalid data type to trigger an exception
+    api._request = AsyncMock(return_value=(200, {"code": "0", "data": []}))
+
+    with patch(
+        "hyxi_cloud_api.api._parse_ems_kv", side_effect=Exception("Parsing error")
+    ):
+        result = await api.query_ems_basic_details("10602251600016")
+
+    assert result == {}
+    assert "HYXI EMS Basic Data Request Failed for" in caplog.text
+
+
+@pytest.mark.asyncio
+async def test_fetch_device_metrics_parsing_error(caplog, monkeypatch):
+    """Test that _fetch_device_metrics handles parsing errors gracefully."""
+    caplog.set_level(logging.ERROR)
+    mock_session = MagicMock()
+    api = HyxiApiClient("ak", "sk", "https://api.com", mock_session)
+
+    # Return a success response so that it enters the 'if res_q.get("success"):' block
+    api._request = AsyncMock(
+        return_value=(200, {"success": True, "data": [{"key": "bad"}]})
+    )
+
+    def mock_parse(*args, **kwargs):
+        raise ValueError("Mock parsing error")
+
+    # Mock _parse_data_list to trigger the exception block at line 1234
+    import hyxi_cloud_api.api as api_module  # pylint: disable=import-outside-toplevel
+
+    monkeypatch.setattr(api_module, "_parse_data_list", mock_parse)
+
+    entry = {"metrics": {}, "device_type_code": "INVERTER"}
+    await api._fetch_device_metrics("10602251600016", entry)
+
+    assert "Error fetching metrics for " in caplog.text
+    assert "Mock parsing error" in caplog.text

{hyxi_cloud_api-1.3.9 → hyxi_cloud_api-1.4.0}/tests/test_push.py

@@ -267,8 +267,8 @@ def test_process_push_data_nested_format():
     assert metrics["gridP"] == -1.5
     assert metrics["gridF"] == 50.02
     assert metrics["gridPfd"] == 0.98
-    assert metrics["gridEIn"] == 1023.4
-    assert metrics["gridEOut"] == 504.2
+    assert metrics["totalEnt"] == 1023.4
+    assert metrics["totalEpt"] == 504.2
     assert metrics["grid_import"] == 1500.0
     assert metrics["grid_export"] == 0.0
 

{hyxi_cloud_api-1.3.9 → hyxi_cloud_api-1.4.0}/tests/test_sanitize_dict.py

@@ -2,7 +2,7 @@
 
 from unittest.mock import patch
 
-from src.hyxi_cloud_api.api import _sanitize_dict, _sanitize_list
+from hyxi_cloud_api.api import _sanitize_dict, _sanitize_list
 
 
 def test_sanitize_dict_plant_address():
@@ -16,7 +16,7 @@ def test_sanitize_dict_plant_address():
     assert result["plantAddress"] == "[REDACTED]"
 
 
-@patch("src.hyxi_cloud_api.api._mask_id", return_value="MASKED")
+@patch("hyxi_cloud_api.api._mask_id", return_value="MASKED")
 def test_sanitize_dict_sensitive_keys(mock_mask_id):
     """Test that keys matching _SENSITIVE_KEYS are correctly masked."""
     raw = {
@@ -25,7 +25,7 @@ def test_sanitize_dict_sensitive_keys(mock_mask_id):
         "plantId": None,  # falsy value
     }
     with patch(
-        "src.hyxi_cloud_api.api._SENSITIVE_KEYS", {"deviceSn", "parentSn", "plantId"}
+        "hyxi_cloud_api.api._SENSITIVE_KEYS", {"deviceSn", "parentSn", "plantId"}
     ):
         result = _sanitize_dict(raw)
 
@@ -60,7 +60,7 @@ def test_sanitize_dict_alarmstate_passthrough():
     assert result["alarmState"] == "inactive"
 
 
-@patch("src.hyxi_cloud_api.api._mask_id", return_value="MASKED")
+@patch("hyxi_cloud_api.api._mask_id", return_value="MASKED")
 def test_sanitize_dict_auth_keys(mock_mask_id):
     """Test that authentication keys are correctly masked."""
     raw = {
@@ -70,7 +70,7 @@ def test_sanitize_dict_auth_keys(mock_mask_id):
         "password": "super_secret_password",
     }
     with patch(
-        "src.hyxi_cloud_api.api._SENSITIVE_KEYS",
+        "hyxi_cloud_api.api._SENSITIVE_KEYS",
         {"token", "access_token", "refresh_token", "password"},
     ):
         result = _sanitize_dict(raw)
@@ -128,8 +128,8 @@ def test_sanitize_list():
         "",
         [{"plantId": "987654321", "otherKey": 123}, ""],
     ]
-    with patch("src.hyxi_cloud_api.api._SENSITIVE_KEYS", {"deviceSn", "plantId"}):
-        with patch("src.hyxi_cloud_api.api._mask_id", return_value="MASKED"):
+    with patch("hyxi_cloud_api.api._SENSITIVE_KEYS", {"deviceSn", "plantId"}):
+        with patch("hyxi_cloud_api.api._mask_id", return_value="MASKED"):
             result = _sanitize_list(raw_list)
 
     expected = [
@@ -160,10 +160,10 @@ def test_sanitize_list_edge_cases():
         [[{"password": "xyz", "empty": ""}, ""]],
     ]
     with patch(
-        "src.hyxi_cloud_api.api._SENSITIVE_KEYS",
+        "hyxi_cloud_api.api._SENSITIVE_KEYS",
         {"deviceSn", "plantId", "token", "password"},
     ):
-        with patch("src.hyxi_cloud_api.api._mask_id", return_value="MASKED"):
+        with patch("hyxi_cloud_api.api._mask_id", return_value="MASKED"):
             result = _sanitize_list(raw_list)
 
     expected = [

{hyxi_cloud_api-1.3.9 → hyxi_cloud_api-1.4.0}/tests/test_sanitize_list.py

@@ -2,7 +2,7 @@
 
 from unittest.mock import patch
 
-from src.hyxi_cloud_api.api import _sanitize_list
+from hyxi_cloud_api.api import _sanitize_list
 
 
 def test_sanitize_list_empty():
@@ -29,7 +29,7 @@ def test_sanitize_list_nested():
     assert _sanitize_list(raw) == [1, [None, 2], None]
 
 
-@patch("src.hyxi_cloud_api.api._mask_id", return_value="MASKED")
+@patch("hyxi_cloud_api.api._mask_id", return_value="MASKED")
 def test_sanitize_list_with_dicts(mock_mask):
     """Test that dictionaries within a list are sanitized correctly."""
     raw = [{"deviceSn": "123456789"}, ""]

hyxi_cloud_api-1.4.0/tests/test_set_log_salt.py

@@ -0,0 +1,55 @@
+"""Tests for the set_log_salt function in api.py."""
+
+import pytest
+
+from hyxi_cloud_api import api
+from hyxi_cloud_api.api import _mask_id, set_log_salt
+
+
+@pytest.fixture(autouse=True)
+def restore_log_salt():
+    """Fixture to ensure the original _LOG_SALT is restored after each test."""
+    original_salt = api._LOG_SALT
+    yield
+    api._LOG_SALT = original_salt
+    _mask_id.cache_clear()
+
+
+def test_set_log_salt_with_string():
+    """Test that setting log salt with a string correctly encodes it to bytes and clears cache."""
+    # Given an initial salt
+    set_log_salt(b"initial_salt_123")
+
+    # Pre-populate cache for a specific ID
+    test_id = "test_sn_123"
+    initial_masked = _mask_id(test_id)
+
+    # Act
+    set_log_salt("new_string_salt")
+
+    # Assert
+    assert api._LOG_SALT == b"new_string_salt"
+
+    # Verify the cache was cleared and new salt is used
+    new_masked = _mask_id(test_id)
+    assert new_masked != initial_masked
+
+
+def test_set_log_salt_with_bytes():
+    """Test that setting log salt with bytes correctly assigns it and clears cache."""
+    # Given an initial salt
+    set_log_salt("initial_salt_123")
+
+    # Pre-populate cache for a specific ID
+    test_id = "test_sn_123"
+    initial_masked = _mask_id(test_id)
+
+    # Act
+    set_log_salt(b"new_bytes_salt")
+
+    # Assert
+    assert api._LOG_SALT == b"new_bytes_salt"
+
+    # Verify the cache was cleared and new salt is used
+    new_masked = _mask_id(test_id)
+    assert new_masked != initial_masked