hyxi-cloud-api 1.3.5__tar.gz → 1.3.7__tar.gz

{hyxi_cloud_api-1.3.5/src/hyxi_cloud_api.egg-info → hyxi_cloud_api-1.3.7}/PKG-INFO

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

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

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

{hyxi_cloud_api-1.3.5 → hyxi_cloud_api-1.3.7}/src/hyxi_cloud_api/api.py

@@ -72,6 +72,8 @@ _COLLECTOR_FILTER_REGEX = re.compile(
 
 _PV_KEYS = tuple((f"pv{i}v", f"pv{i}i", f"pv{i}p") for i in range(1, 5))
 
+_METRICS_EXCLUDED_KEYS = frozenset({"deviceSn", "reportTimestamp", "collectTime"})
+
 # Official HYXI Alarm Code Reference Table
 ALARM_CODE_MAP = {
     "704": "The ambient temperature is too high",
@@ -600,8 +602,16 @@ def _compute_load_metrics(m_raw: dict, derived: dict[str, float]) -> None:
 
 def _compute_grid_metrics(m_raw: dict, derived: dict[str, float]) -> None:
     """Calculate grid import/export metrics."""
-    if "gridP" in m_raw:
+    grid = None
+    if "gridP" in m_raw and m_raw["gridP"] is not None and m_raw["gridP"] != "":
         grid = _get_f("gridP", m_raw, 1000.0)
+    elif "ph1p" in m_raw or "ph2p" in m_raw or "ph3p" in m_raw:
+        # Sum up individual phase powers (which are in Watts) to compute grid power fallback
+        grid = _get_f("ph1p", m_raw) + _get_f("ph2p", m_raw) + _get_f("ph3p", m_raw)
+        # Store the derived gridP back in metrics (in kW to align with API standard format)
+        derived["gridP"] = round(grid / 1000.0, 4)
+
+    if grid is not None:
         derived["grid_import"] = abs(grid) if grid < 0 else 0.0
         derived["grid_export"] = grid if grid > 0 else 0.0
 
@@ -626,10 +636,38 @@ def _compute_battery_metrics(
         derived["bat_discharging"] = power_source if power_source > 0 else 0.0
         derived["bat_power_dc"] = bat_p_dc
 
-    if "batCharge" in m_raw:
-        derived["bat_charge_total"] = _get_f("batCharge", m_raw)
-    if "batDisCharge" in m_raw:
-        derived["bat_discharge_total"] = _get_f("batDisCharge", m_raw)
+    def _is_valid_metric(k: str) -> bool:
+        v = m_raw.get(k)
+        if v is None:
+            return False
+        if isinstance(v, str):
+            v_cleaned = v.strip().lower()
+            return bool(v_cleaned and v_cleaned not in ("null", "none", "na", "--"))
+        return True
+
+    # Unify cumulative battery charge energy telemetry keys to resolve polling/push mismatch
+    charge_val = None
+    if _is_valid_metric("batCharge"):
+        charge_val = _get_f("batCharge", m_raw)
+    elif _is_valid_metric("totalEchg"):
+        charge_val = _get_f("totalEchg", m_raw)
+
+    if charge_val is not None:
+        derived["bat_charge_total"] = charge_val
+        derived["totalEchg"] = charge_val
+        derived["batCharge"] = charge_val
+
+    # Unify cumulative battery discharge energy telemetry keys to resolve polling/push mismatch
+    discharge_val = None
+    if _is_valid_metric("batDisCharge"):
+        discharge_val = _get_f("batDisCharge", m_raw)
+    elif _is_valid_metric("totalEdchg"):
+        discharge_val = _get_f("totalEdchg", m_raw)
+
+    if discharge_val is not None:
+        derived["bat_discharge_total"] = discharge_val
+        derived["totalEdchg"] = discharge_val
+        derived["batDisCharge"] = discharge_val
 
 
 def _compute_pv_metrics(m_raw: dict, derived: dict[str, float]) -> None:
@@ -820,6 +858,23 @@ def _flatten_nested_push_device(device: dict) -> dict:  # pylint: disable=too-ma
                 if "epsPowerW" in phi:
                     flat[f"ph{i}Loadp"] = phi["epsPowerW"]
 
+    # 9. grid
+    if "grid" in device and isinstance(device["grid"], dict):
+        grd = device["grid"]
+        if "powerW" in grd and grd["powerW"] is not None:
+            try:
+                flat["gridP"] = float(grd["powerW"]) / 1000.0
+            except ValueError, TypeError:
+                flat["gridP"] = grd["powerW"]
+        if "frequencyHz" in grd:
+            flat["gridF"] = grd["frequencyHz"]
+        if "powerFactor" in grd:
+            flat["gridPfd"] = grd["powerFactor"]
+        if "energyInKwh" in grd:
+            flat["gridEIn"] = grd["energyInKwh"]
+        if "energyOutKwh" in grd:
+            flat["gridEOut"] = 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):
@@ -2124,7 +2179,7 @@ class HyxiApiClient:  # pylint: disable=too-many-instance-attributes
             # Strip metadata/routing keys
             raw_metrics = {}
             for k, v in device.items():
-                if k in ("deviceSn", "reportTimestamp", "collectTime"):
+                if k in _METRICS_EXCLUDED_KEYS:
                     continue
                 raw_metrics[k] = v
 
@@ -2225,7 +2280,7 @@ class HyxiApiClient:  # pylint: disable=too-many-instance-attributes
             if not sn:
                 continue
 
-            alarm_code = str(item.get("alarmCode", ""))
+            alarm_code = f"{item.get('alarmCode', '')}"
 
             # Resolve alarm name: use payload name if present, fall back to ALARM_CODE_MAP
             alarm_name = item.get("alarmName") or ALARM_CODE_MAP.get(

{hyxi_cloud_api-1.3.5 → hyxi_cloud_api-1.3.7/src/hyxi_cloud_api.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: hyxi-cloud-api
-Version: 1.3.5
+Version: 1.3.7
 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.5 → hyxi_cloud_api-1.3.7}/tests/test_compute_battery_metrics.py

@@ -60,6 +60,37 @@ def test_compute_battery_metrics_totals():
     _compute_battery_metrics(m_raw, derived, "OTHER")
     assert derived["bat_charge_total"] == 12.5
     assert derived["bat_discharge_total"] == 45.6
+    assert derived["totalEchg"] == 12.5
+    assert derived["totalEdchg"] == 45.6
+    assert derived["batCharge"] == 12.5
+    assert derived["batDisCharge"] == 45.6
+
+
+def test_compute_battery_metrics_polling_keys():
+    """Test fallback and synchronization when only polling keys are present."""
+    derived: dict[str, float] = {}
+    m_raw = {"totalEchg": 100.5, "totalEdchg": 200.2}
+    _compute_battery_metrics(m_raw, derived, "OTHER")
+    assert derived["bat_charge_total"] == 100.5
+    assert derived["bat_discharge_total"] == 200.2
+    assert derived["totalEchg"] == 100.5
+    assert derived["totalEdchg"] == 200.2
+    assert derived["batCharge"] == 100.5
+    assert derived["batDisCharge"] == 200.2
+
+
+def test_compute_battery_metrics_null_and_empty_handling():
+    """Verify that null-equivalent and empty values do not pollute derived metrics."""
+    derived: dict[str, float] = {}
+    m_raw = {
+        "batCharge": 150.0,
+        "totalEchg": "null",
+        "batDisCharge": "None",
+        "totalEdchg": 250.0,
+    }
+    _compute_battery_metrics(m_raw, derived, "OTHER")
+    assert derived["bat_charge_total"] == 150.0
+    assert derived["bat_discharge_total"] == 250.0
 
 
 def test_compute_battery_metrics_empty():

hyxi_cloud_api-1.3.7/tests/test_compute_grid_metrics.py

@@ -0,0 +1,79 @@
+"""Tests for the _compute_grid_metrics helper function in api.py."""
+
+from src.hyxi_cloud_api.api import _compute_grid_metrics
+
+
+class TestComputeGridMetrics:
+    """Tests for _compute_grid_metrics."""
+
+    def test_grid_import(self):
+        """Test grid_import when gridP is negative."""
+        m_raw = {"gridP": -1.5}
+        derived: dict[str, float] = {}
+        _compute_grid_metrics(m_raw, derived)
+        assert derived["grid_import"] == 1500.0
+        assert derived["grid_export"] == 0.0
+
+    def test_grid_export(self):
+        """Test grid_export when gridP is positive."""
+        m_raw = {"gridP": 2.25}
+        derived: dict[str, float] = {}
+        _compute_grid_metrics(m_raw, derived)
+        assert derived["grid_import"] == 0.0
+        assert derived["grid_export"] == 2250.0
+
+    def test_grid_zero(self):
+        """Test grid import/export when gridP is zero."""
+        m_raw = {"gridP": 0.0}
+        derived: dict[str, float] = {}
+        _compute_grid_metrics(m_raw, derived)
+        assert derived["grid_import"] == 0.0
+        assert derived["grid_export"] == 0.0
+
+    def test_grid_missing(self):
+        """Test missing gridP."""
+        m_raw = {}
+        derived: dict[str, float] = {}
+        _compute_grid_metrics(m_raw, derived)
+        assert "grid_import" not in derived
+        assert "grid_export" not in derived
+
+    def test_grid_fallback_phases_positive(self):
+        """Test grid fallback to phase active powers when gridP is missing."""
+        m_raw = {
+            "ph1p": 200.0,
+            "ph2p": 150.0,
+            "ph3p": 50.0,
+        }
+        derived: dict[str, float] = {}
+        _compute_grid_metrics(m_raw, derived)
+        assert derived["gridP"] == 0.4  # (200 + 150 + 50) / 1000 = 0.4 kW
+        assert derived["grid_import"] == 0.0
+        assert derived["grid_export"] == 400.0
+
+    def test_grid_fallback_phases_negative(self):
+        """Test grid fallback to phase active powers when importing (negative)."""
+        m_raw = {
+            "ph1p": -300.0,
+            "ph2p": -200.0,
+            "ph3p": -100.0,
+        }
+        derived: dict[str, float] = {}
+        _compute_grid_metrics(m_raw, derived)
+        assert derived["gridP"] == -0.6  # -600W / 1000 = -0.6 kW
+        assert derived["grid_import"] == 600.0
+        assert derived["grid_export"] == 0.0
+
+    def test_grid_priority(self):
+        """Test that gridP takes priority over phase fallback if present."""
+        m_raw = {
+            "gridP": 1.5,
+            "ph1p": -300.0,
+            "ph2p": -200.0,
+            "ph3p": -100.0,
+        }
+        derived: dict[str, float] = {}
+        _compute_grid_metrics(m_raw, derived)
+        assert "gridP" not in derived  # gridP was in m_raw, not computed/derived
+        assert derived["grid_import"] == 0.0
+        assert derived["grid_export"] == 1500.0

{hyxi_cloud_api-1.3.5 → hyxi_cloud_api-1.3.7}/tests/test_device_control.py

@@ -221,6 +221,30 @@ async def test_set_micro_power_limit_invalid_percentage():
         await api.set_micro_power_limit("SN123", percentage=-1)
 
 
+@pytest.mark.asyncio
+async def test_set_micro_power_limit_mocked_control():
+    """Test set_micro_power_limit by mocking set_device_control and checking edge cases."""
+    api = HyxiApiClient("ak", "sk", "https://api.com", MagicMock())
+    api.set_device_control = AsyncMock(return_value={"success": True})
+
+    # Test 80%
+    result = await api.set_micro_power_limit("SN123", percentage=80)
+    api.set_device_control.assert_awaited_once_with("SN123", {3012: "80"})
+    assert result == {"success": True}
+
+    # Test boundary 0%
+    api.set_device_control.reset_mock()
+    result = await api.set_micro_power_limit("SN123", percentage=0)
+    api.set_device_control.assert_awaited_once_with("SN123", {3012: "0"})
+    assert result == {"success": True}
+
+    # Test boundary 100%
+    api.set_device_control.reset_mock()
+    result = await api.set_micro_power_limit("SN123", percentage=100)
+    api.set_device_control.assert_awaited_once_with("SN123", {3012: "100"})
+    assert result == {"success": True}
+
+
 @pytest.mark.asyncio
 async def test_restart_device():
     """Test restart_device sends controlId 3013 with value '1'."""

{hyxi_cloud_api-1.3.5 → hyxi_cloud_api-1.3.7}/tests/test_push.py

@@ -218,6 +218,13 @@ def test_process_push_data_nested_format():
                         "epsPowerW": 269.0,
                     }
                 },
+                "grid": {
+                    "powerW": -1500.0,
+                    "frequencyHz": 50.02,
+                    "powerFactor": 0.98,
+                    "energyInKwh": 1023.4,
+                    "energyOutKwh": 504.2,
+                },
             }
         ]
     }
@@ -257,6 +264,13 @@ def test_process_push_data_nested_format():
     assert metrics["ph1i"] == 1.88
     assert metrics["ph1p"] == 450.0
     assert metrics["ph1Loadp"] == 269.0
+    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["grid_import"] == 1500.0
+    assert metrics["grid_export"] == 0.0
 
 
 def test_process_push_data_flat_ms_collect_time():

{hyxi_cloud_api-1.3.5 → hyxi_cloud_api-1.3.7}/tests/test_subscriptions.py

@@ -57,6 +57,46 @@ async def test_subscribe_real_time_data():
     }
 
 
+@pytest.mark.asyncio
+async def test_subscribe_real_time_data_mock_post_subscription():
+    """Test real-time data subscription by mocking _post_subscription."""
+    api = _client()
+    api._post_subscription = AsyncMock(return_value={"success": True, "data": "mocked"})
+
+    # Test with data_code_list
+    result = await api.subscribe_real_time_data(
+        callback_url="https://example.com/hyxi",
+        device_sn_list=["SN1"],
+        post_rate=5000,
+        data_code_list=["pv1p"],
+    )
+    assert result == {"success": True, "data": "mocked"}
+    api._post_subscription.assert_called_with(
+        "/api/subscribe/v1/realTimeData",
+        {
+            "callBackUrl": "https://example.com/hyxi",
+            "deviceSnList": ["SN1"],
+            "postRate": 5000,
+            "dataCodeList": ["pv1p"],
+        },
+    )
+
+    # Test without data_code_list
+    result = await api.subscribe_real_time_data(
+        callback_url="https://example.com/hyxi",
+        device_sn_list=["SN1"],
+        post_rate=5000,
+    )
+    api._post_subscription.assert_called_with(
+        "/api/subscribe/v1/realTimeData",
+        {
+            "callBackUrl": "https://example.com/hyxi",
+            "deviceSnList": ["SN1"],
+            "postRate": 5000,
+        },
+    )
+
+
 @pytest.mark.asyncio
 async def test_subscribe_alarm():
     """Test alarm subscription payload."""
@@ -109,6 +149,23 @@ async def test_cancel_subscription():
     assert call_args.kwargs["json"] == {"subscribeCode": "sub-code"}
 
 
+@pytest.mark.asyncio
+async def test_cancel_subscription_return_value():
+    """Test subscription cancellation return value matches expected API response."""
+    api = _client()
+
+    # Execute the method
+    result = await api.cancel_subscription("valid-sub-code")
+
+    # Verify the return payload matches the API response
+    assert result == {
+        "code": "0",
+        "msg": "Success",
+        "data": {"subscribeCode": "sub-code"},
+        "success": True,
+    }
+
+
 @pytest.mark.asyncio
 async def test_subscription_error_on_auth_failed():
     """Test SubscriptionError is raised when authentication fails."""

hyxi_cloud_api-1.3.5/tests/test_compute_grid_metrics.py

@@ -1,39 +0,0 @@
-"""Tests for the _compute_grid_metrics helper function in api.py."""
-
-from src.hyxi_cloud_api.api import _compute_grid_metrics
-
-
-class TestComputeGridMetrics:
-    """Tests for _compute_grid_metrics."""
-
-    def test_grid_import(self):
-        """Test grid_import when gridP is negative."""
-        m_raw = {"gridP": -1.5}
-        derived: dict[str, float] = {}
-        _compute_grid_metrics(m_raw, derived)
-        assert derived["grid_import"] == 1500.0
-        assert derived["grid_export"] == 0.0
-
-    def test_grid_export(self):
-        """Test grid_export when gridP is positive."""
-        m_raw = {"gridP": 2.25}
-        derived: dict[str, float] = {}
-        _compute_grid_metrics(m_raw, derived)
-        assert derived["grid_import"] == 0.0
-        assert derived["grid_export"] == 2250.0
-
-    def test_grid_zero(self):
-        """Test grid import/export when gridP is zero."""
-        m_raw = {"gridP": 0.0}
-        derived: dict[str, float] = {}
-        _compute_grid_metrics(m_raw, derived)
-        assert derived["grid_import"] == 0.0
-        assert derived["grid_export"] == 0.0
-
-    def test_grid_missing(self):
-        """Test missing gridP."""
-        m_raw = {}
-        derived: dict[str, float] = {}
-        _compute_grid_metrics(m_raw, derived)
-        assert "grid_import" not in derived
-        assert "grid_export" not in derived