pyimouapi 1.2.8__tar.gz → 1.3.0__tar.gz

{pyimouapi-1.2.8 → pyimouapi-1.3.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: pyimouapi
-Version: 1.2.8
+Version: 1.3.0
 Summary: A package for imou open api
 Home-page: https://github.com/Imou-OpenPlatform/Py-Imou-Open-Api
 Author: Imou-OpenPlatform

{pyimouapi-1.2.8 → pyimouapi-1.3.0}/pyimouapi/__init__.py

@@ -1,4 +1,4 @@
-__version__ = "1.2.8"
+__version__ = "1.3.0"
 
 from .device import ImouChannel, ImouDevice, ImouDeviceManager
 from .exceptions import (

{pyimouapi-1.2.8 → pyimouapi-1.3.0}/pyimouapi/const.py

@@ -22,6 +22,7 @@ API_ENDPOINT_GET_DEVICE_POWER_INFO = "/openapi/getDevicePowerInfo"
 API_ENDPOINT_GET_PRODUCT_MODEL = "/openapi/getProductModel"
 API_ENDPOINT_GET_IOT_DEVICE_DETAIL_INFO = "/openapi/getIotDeviceDetailInfo"
 API_ENDPOINT_WAKE_UP_DEVICE = "/openapi/wakeUpDevice"
+API_ENDPOINT_SET_MESSAGE_CALLBACK = "/openapi/setMessageCallback"
 
 # error_codes
 ERROR_CODE_SUCCESS = "0"
@@ -116,6 +117,9 @@ PARAM_LITELEC = "litElec"
 PARAM_ALKELEC = "alkElec"
 PARAM_SERVICES = "services"
 PARAM_STATE = "state"
+PARAM_STATE_VARIANT = "state_variant"
+STATE_VARIANT_NUMERIC = "numeric"
+STATE_VARIANT_ENUM = "enum"
 PARAM_TYPE = "type"
 PARAM_EXCEPTS = "excepts"
 PARAM_ABILITY_REFS = "abilityRefs"

{pyimouapi-1.2.8 → pyimouapi-1.3.0}/pyimouapi/device.py

@@ -1,5 +1,6 @@
 from __future__ import annotations
 
+from dataclasses import dataclass
 from typing import Any
 
 from .const import (
@@ -64,6 +65,14 @@ from .const import (
 from .openapi import ImouOpenApiClient
 
 
+@dataclass(frozen=True)
+class ImouDeviceSummary:
+    device_id: str
+    name: str
+    model: str
+    status: str  # "0" offline, "1" online
+
+
 class ImouChannel:
     def __init__(
         self,
@@ -286,6 +295,38 @@ class ImouDeviceManager:
             devices.extend(await self.async_get_devices(page + 1, page_size))
         return devices
 
+    async def async_get_device_summaries(
+        self, page: int = 1, page_size: int = 50
+    ) -> list[ImouDeviceSummary]:
+        params = {
+            PARAM_PAGE: page,
+            PARAM_PAGE_SIZE: page_size,
+        }
+        data = await self._imou_api_client.async_request_api(
+            API_ENDPOINT_LIST_DEVICE_DETAILS, params
+        )
+        if data[PARAM_COUNT] == 0:
+            return []
+        summaries: list[ImouDeviceSummary] = []
+        for device in data[PARAM_DEVICE_LIST]:
+            device_id = device.get(PARAM_DEVICE_ID)
+            if not device_id:
+                continue
+            name = device.get(PARAM_DEVICE_NAME) or device_id
+            model = device.get(PARAM_DEVICE_MODEL, "")
+            status = str(device.get(PARAM_DEVICE_STATUS, ""))
+            summaries.append(
+                ImouDeviceSummary(
+                    device_id=device_id,
+                    name=name,
+                    model=model,
+                    status=status,
+                )
+            )
+        if data[PARAM_COUNT] >= page_size:
+            summaries.extend(await self.async_get_device_summaries(page + 1, page_size))
+        return summaries
+
     async def async_control_device_ptz(
         self, device_id: str, channel_id: str, operation: int, duration: int
     ) -> None:

{pyimouapi-1.2.8 → pyimouapi-1.3.0}/pyimouapi/ha_device.py

@@ -67,6 +67,7 @@ from .const import (
 )
 from .device import ImouDevice, ImouDeviceManager
 from .exceptions import RequestFailedException
+from .sensor import apply_sensor_state
 
 _LOGGER: logging.Logger = logging.getLogger(__package__)
 
@@ -146,9 +147,8 @@ class ImouHaDevice:
         self._model = model
         self._swversion = swversion
         self._switches = {}
-        self._sensors = {
-            PARAM_STATUS: {PARAM_STATE: DeviceStatus.OFFLINE.value},
-        }
+        self._sensors: dict[str, dict[str, Any]] = {}
+        apply_sensor_state(self._sensors, PARAM_STATUS, DeviceStatus.OFFLINE.value)
         self._binary_sensors = {}
         self._selects = {}
         self._buttons = {}
@@ -348,8 +348,12 @@ class ImouHaDeviceManager:
                 state = self.get_expression_value(meta[PARAM_EXPRESSION], raw_value)
             else:
                 state = raw_value
-            target = device.sensors if kind == "sensor" else device.texts
-            target[key][PARAM_STATE] = str(state) if isinstance(state, int) else state
+            if kind == "sensor":
+                apply_sensor_state(device.sensors, key, state)
+            else:
+                device.texts[key][PARAM_STATE] = (
+                    str(state) if isinstance(state, int) else state
+                )
 
     async def _async_fetch_device_detail(self, device: ImouHaDevice) -> dict[str, Any]:
         return await self.delegate.async_get_iot_device_detail_info(
@@ -472,14 +476,18 @@ class ImouHaDeviceManager:
                 )
             data = await self.delegate.async_get_device_online_status(device_id)
             if device.channel_id is None and device.product_id is not None:
-                device.sensors[PARAM_STATUS][PARAM_STATE] = self.get_device_status(
-                    data[PARAM_ONLINE]
+                apply_sensor_state(
+                    device.sensors,
+                    PARAM_STATUS,
+                    self.get_device_status(data[PARAM_ONLINE]),
                 )
             else:
                 for channel in data[PARAM_CHANNELS]:
                     if channel[PARAM_CHANNEL_ID] == device.channel_id:
-                        device.sensors[PARAM_STATUS][PARAM_STATE] = (
-                            self.get_device_status(channel[PARAM_ONLINE])
+                        apply_sensor_state(
+                            device.sensors,
+                            PARAM_STATUS,
+                            self.get_device_status(channel[PARAM_ONLINE]),
                         )
                         break
         except Exception as e:
@@ -492,15 +500,15 @@ class ImouHaDeviceManager:
                 percentage_used = int(
                     data[PARAM_USED_BYTES] * 100 / data[PARAM_TOTAL_BYTES]
                 )
-                device.sensors[PARAM_STORAGE_USED][PARAM_STATE] = str(percentage_used)
+                apply_sensor_state(device.sensors, PARAM_STORAGE_USED, percentage_used)
             else:
-                device.sensors[PARAM_STORAGE_USED][PARAM_STATE] = "e2"
+                apply_sensor_state(device.sensors, PARAM_STORAGE_USED, "e2")
         except RequestFailedException as exception:
             _LOGGER.error(f"_async_update_device_storage error:  {exception}")
             if ERROR_CODE_NO_STORAGE_MEDIUM in exception.message:
-                device.sensors[PARAM_STORAGE_USED][PARAM_STATE] = "e1"
+                apply_sensor_state(device.sensors, PARAM_STORAGE_USED, "e1")
             else:
-                device.sensors[PARAM_STORAGE_USED][PARAM_STATE] = "e2"
+                apply_sensor_state(device.sensors, PARAM_STORAGE_USED, "e2")
 
     async def async_get_device_stream(
         self, device: ImouHaDevice, live_resolution: str, live_protocol: str
@@ -843,11 +851,12 @@ class ImouHaDeviceManager:
                     sensor_type,
                     imou_ha_device.sensors,
                 ):
-                    imou_ha_device.sensors[sensor_type] = {
-                        PARAM_STATE: "unknown"
-                        if sensor_type not in NUMBER_TYPE
-                        else "0"
-                    }
+                    imou_ha_device.sensors[sensor_type] = {}
+                    apply_sensor_state(
+                        imou_ha_device.sensors,
+                        sensor_type,
+                        "unknown" if sensor_type not in NUMBER_TYPE else "0",
+                    )
 
     @staticmethod
     def configure_select_by_ability(
@@ -1119,10 +1128,12 @@ class ImouHaDeviceManager:
                 ):
                     imou_ha_device.sensors[sensor_type] = {
                         PARAM_REF: ref[PARAM_REF],
-                        PARAM_STATE: ref[PARAM_DEFAULT],
                         PARAM_REF_TYPE: ref.get(PARAM_REF_TYPE),
                         PARAM_EXPRESSION: ref.get(PARAM_EXPRESSION),
                     }
+                    apply_sensor_state(
+                        imou_ha_device.sensors, sensor_type, ref[PARAM_DEFAULT]
+                    )
                     break
 
     @staticmethod
@@ -1224,9 +1235,7 @@ class ImouHaDeviceManager:
             )
             if state is None:
                 return
-            device.sensors[sensor_type][PARAM_STATE] = (
-                str(state) if isinstance(state, int) else state
-            )
+            apply_sensor_state(device.sensors, sensor_type, state)
         except Exception as e:
             _LOGGER.error(f"_async_update_device_sensor_status_by_ref fail:{e}")
 
@@ -1387,22 +1396,16 @@ class ImouHaDeviceManager:
     async def _async_update_device_battery(self, device, retry: bool = False):
         try:
             data = await self.delegate.async_get_device_power_info(device.device_id)
+            battery_level = "0"
             if data.get(PARAM_ELECTRICITYS):
                 electricity = data[PARAM_ELECTRICITYS][0]
                 if PARAM_LITELEC in electricity:
-                    device.sensors[PARAM_BATTERY][PARAM_STATE] = str(
-                        electricity[PARAM_LITELEC]
-                    )
+                    battery_level = electricity[PARAM_LITELEC]
                 elif PARAM_ALKELEC in electricity:
-                    device.sensors[PARAM_BATTERY][PARAM_STATE] = str(
-                        electricity[PARAM_ALKELEC]
-                    )
+                    battery_level = electricity[PARAM_ALKELEC]
                 elif PARAM_ELECTRIC in electricity:
-                    device.sensors[PARAM_BATTERY][PARAM_STATE] = str(
-                        electricity[PARAM_ELECTRIC]
-                    )
-            else:
-                device.sensors[PARAM_BATTERY][PARAM_STATE] = "0"
+                    battery_level = electricity[PARAM_ELECTRIC]
+            apply_sensor_state(device.sensors, PARAM_BATTERY, battery_level)
         except RequestFailedException as exception:
             # 如果在休眠，则唤醒设备后重试一次
             if ERROR_CODE_DEVICE_SLEEPING in exception.message and not retry:
@@ -1411,10 +1414,10 @@ class ImouHaDeviceManager:
                     await self._async_update_device_battery(device, True)
                 except RequestFailedException as e:
                     _LOGGER.error(f"_async_update_device_battery error:  {e}")
-                    device.sensors[PARAM_BATTERY][PARAM_STATE] = "0"
+                    apply_sensor_state(device.sensors, PARAM_BATTERY, "0")
             else:
                 _LOGGER.error(f"_async_update_device_battery error:  {exception}")
-                device.sensors[PARAM_BATTERY][PARAM_STATE] = "0"
+                apply_sensor_state(device.sensors, PARAM_BATTERY, "0")
 
     @staticmethod
     def configure_text_by_ref(

{pyimouapi-1.2.8 → pyimouapi-1.3.0}/pyimouapi/openapi.py

@@ -5,13 +5,15 @@ import logging
 import secrets
 import time
 import uuid
-from typing import Any
+from collections.abc import Iterable
+from typing import Any, Literal
 from urllib.parse import urlparse
 
 import aiohttp
 
 from .const import (
     API_ENDPOINT_ACCESS_TOKEN,
+    API_ENDPOINT_SET_MESSAGE_CALLBACK,
     ERROR_CODE_INVALID_APP,
     ERROR_CODE_INVALID_SIGN,
     ERROR_CODE_SUCCESS,
@@ -133,6 +135,31 @@ class ImouOpenApiClient:
         response_data = response_body[PARAM_RESULT].get(PARAM_DATA, {})
         return response_data
 
+    async def async_set_message_callback(
+        self,
+        *,
+        status: Literal["on", "off"],
+        callback_url: str | None = None,
+        callback_flag: str | Iterable[str] | None = None,
+        base_push: str = "2",
+    ) -> dict[str, Any]:
+        """Register or unregister Imou Open Platform message callback."""
+        params: dict[str, Any] = {
+            "status": status,
+            "basePush": base_push,
+        }
+        if status == "on":
+            if callback_url is None:
+                raise ValueError("callback_url is required when status is 'on'")
+            params["callbackUrl"] = callback_url
+            if callback_flag is None:
+                params["callbackFlag"] = "alarm,deviceStatus"
+            elif isinstance(callback_flag, str):
+                params["callbackFlag"] = callback_flag
+            else:
+                params["callbackFlag"] = ",".join(callback_flag)
+        return await self.async_request_api(API_ENDPOINT_SET_MESSAGE_CALLBACK, params)
+
     @property
     def access_token(self) -> str | None:
         return self._access_token

pyimouapi-1.3.0/pyimouapi/sensor.py

@@ -0,0 +1,95 @@
+"""Sensor state normalization for Home Assistant integrations."""
+
+from __future__ import annotations
+
+import logging
+from typing import Any
+
+from pyimouapi.const import (
+    PARAM_STATE,
+    PARAM_STATE_VARIANT,
+    PARAM_STATUS,
+    PARAM_STORAGE_USED,
+    STATE_VARIANT_ENUM,
+    STATE_VARIANT_NUMERIC,
+)
+
+_LOGGER = logging.getLogger(__name__)
+
+NUMERIC_SENSOR_TYPES = frozenset(
+    {
+        "battery",
+        "temperature_current",
+        "humidity_current",
+        "power",
+        "voltage",
+        "current",
+        "use_electricity",
+        "use_time",
+        "switch_cnt",
+    }
+)
+
+INTEGER_NUMERIC_SENSOR_TYPES = frozenset(
+    {
+        "battery",
+        "use_time",
+        "switch_cnt",
+    }
+)
+
+ENUM_SENSOR_TYPES = frozenset({PARAM_STATUS})
+
+STORAGE_ERROR_CODES = frozenset({"e1", "e2"})
+
+
+def normalize_sensor_state(sensor_type: str, raw: Any) -> tuple[Any, str]:
+    """Return normalized (state, state_variant) for a sensor update."""
+    if sensor_type == PARAM_STORAGE_USED:
+        if isinstance(raw, str) and raw in STORAGE_ERROR_CODES:
+            return raw, STATE_VARIANT_ENUM
+        return _coerce_number(
+            raw, integer=True, sensor_type=sensor_type
+        ), STATE_VARIANT_NUMERIC
+
+    if sensor_type in ENUM_SENSOR_TYPES:
+        return str(raw), STATE_VARIANT_ENUM
+
+    if sensor_type in NUMERIC_SENSOR_TYPES:
+        integer = sensor_type in INTEGER_NUMERIC_SENSOR_TYPES
+        return _coerce_number(
+            raw, integer=integer, sensor_type=sensor_type
+        ), STATE_VARIANT_NUMERIC
+
+    if isinstance(raw, int | float) and not isinstance(raw, bool):
+        return raw, STATE_VARIANT_NUMERIC
+    return raw, STATE_VARIANT_ENUM
+
+
+def _coerce_number(raw: Any, *, integer: bool, sensor_type: str) -> Any:
+    if isinstance(raw, bool):
+        return raw
+    if isinstance(raw, int) and not isinstance(raw, bool):
+        return raw
+    if isinstance(raw, float):
+        return int(raw) if integer else raw
+    if isinstance(raw, str):
+        try:
+            number = float(raw)
+            return int(number) if integer else number
+        except ValueError:
+            _LOGGER.warning(
+                "Could not coerce sensor %s value %r to number", sensor_type, raw
+            )
+            return raw
+    return raw
+
+
+def apply_sensor_state(
+    sensors: dict[str, dict[str, Any]], sensor_type: str, raw: Any
+) -> None:
+    """Write PARAM_STATE and PARAM_STATE_VARIANT on a sensor entry."""
+    state, variant = normalize_sensor_state(sensor_type, raw)
+    bucket = sensors.setdefault(sensor_type, {})
+    bucket[PARAM_STATE] = state
+    bucket[PARAM_STATE_VARIANT] = variant

{pyimouapi-1.2.8 → pyimouapi-1.3.0}/pyimouapi.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: pyimouapi
-Version: 1.2.8
+Version: 1.3.0
 Summary: A package for imou open api
 Home-page: https://github.com/Imou-OpenPlatform/Py-Imou-Open-Api
 Author: Imou-OpenPlatform

{pyimouapi-1.2.8 → pyimouapi-1.3.0}/pyimouapi.egg-info/SOURCES.txt

@@ -8,11 +8,15 @@ pyimouapi/device.py
 pyimouapi/exceptions.py
 pyimouapi/ha_device.py
 pyimouapi/openapi.py
+pyimouapi/sensor.py
 pyimouapi.egg-info/PKG-INFO
 pyimouapi.egg-info/SOURCES.txt
 pyimouapi.egg-info/dependency_links.txt
 pyimouapi.egg-info/requires.txt
 pyimouapi.egg-info/top_level.txt
 tests/test_collect_property_entities.py
+tests/test_device_summaries.py
 tests/test_lookup_property.py
+tests/test_message_callback.py
+tests/test_sensor_normalize.py
 tests/test_update_from_detail.py

{pyimouapi-1.2.8 → pyimouapi-1.3.0}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "pyimouapi"
-version = "1.2.8"
+version = "1.3.0"
 description = "A package for imou open api"
 readme = "README.md"
 requires-python = ">=3.11"

{pyimouapi-1.2.8 → pyimouapi-1.3.0}/setup.py

@@ -4,7 +4,7 @@ from setuptools import find_packages, setup
 
 setup(
     name="pyimouapi",
-    version="1.2.8",
+    version="1.3.0",
     packages=find_packages(),
     python_requires=">=3.11",
     install_requires=[

pyimouapi-1.3.0/tests/test_device_summaries.py

@@ -0,0 +1,89 @@
+"""Tests for ImouDeviceManager.async_get_device_summaries."""
+
+from unittest.mock import AsyncMock, MagicMock
+
+import pytest
+from pyimouapi.const import (
+    API_ENDPOINT_LIST_DEVICE_DETAILS,
+    PARAM_COUNT,
+    PARAM_DEVICE_ID,
+    PARAM_DEVICE_LIST,
+    PARAM_DEVICE_MODEL,
+    PARAM_DEVICE_NAME,
+    PARAM_DEVICE_STATUS,
+    PARAM_PAGE,
+    PARAM_PAGE_SIZE,
+)
+from pyimouapi.device import ImouDeviceManager, ImouDeviceSummary
+
+
+def _make_device(
+    device_id: str,
+    name: str | None = "Camera",
+    model: str = "IPC-A1",
+    status: str | int = "1",
+) -> dict:
+    entry: dict = {
+        PARAM_DEVICE_ID: device_id,
+        PARAM_DEVICE_STATUS: status,
+    }
+    if name is not None:
+        entry[PARAM_DEVICE_NAME] = name
+    if model:
+        entry[PARAM_DEVICE_MODEL] = model
+    return entry
+
+
+@pytest.mark.asyncio
+async def test_get_device_summaries_single_page():
+    client = MagicMock()
+    client.async_request_api = AsyncMock(
+        return_value={
+            PARAM_COUNT: 2,
+            PARAM_DEVICE_LIST: [
+                _make_device("dev1", "Front Door", "IPC-A1", "1"),
+                _make_device("dev2", None, "", "0"),
+                {},
+            ],
+        }
+    )
+    manager = ImouDeviceManager(client)
+
+    summaries = await manager.async_get_device_summaries()
+
+    client.async_request_api.assert_awaited_once_with(
+        API_ENDPOINT_LIST_DEVICE_DETAILS,
+        {PARAM_PAGE: 1, PARAM_PAGE_SIZE: 50},
+    )
+    assert summaries == [
+        ImouDeviceSummary(
+            device_id="dev1", name="Front Door", model="IPC-A1", status="1"
+        ),
+        ImouDeviceSummary(device_id="dev2", name="dev2", model="", status="0"),
+    ]
+
+
+@pytest.mark.asyncio
+async def test_get_device_summaries_pagination():
+    page1_devices = [
+        _make_device(f"dev{i}", f"Device {i}", "IPC", "1") for i in range(50)
+    ]
+    page2_devices = [_make_device("dev50", "Device 50", "IPC", "1")]
+
+    async def mock_request(endpoint, params):
+        if params[PARAM_PAGE] == 1:
+            return {PARAM_COUNT: 50, PARAM_DEVICE_LIST: page1_devices}
+        if params[PARAM_PAGE] == 2:
+            return {PARAM_COUNT: 1, PARAM_DEVICE_LIST: page2_devices}
+        raise AssertionError(f"Unexpected page: {params[PARAM_PAGE]}")
+
+    client = MagicMock()
+    client.async_request_api = AsyncMock(side_effect=mock_request)
+    manager = ImouDeviceManager(client)
+
+    summaries = await manager.async_get_device_summaries()
+
+    assert client.async_request_api.await_count == 2
+    assert len(summaries) == 51
+    assert summaries[0].device_id == "dev0"
+    assert summaries[50].device_id == "dev50"

pyimouapi-1.3.0/tests/test_message_callback.py

@@ -0,0 +1,50 @@
+"""Tests for ImouOpenApiClient.async_set_message_callback."""
+
+from unittest.mock import AsyncMock
+
+import pytest
+from pyimouapi.const import API_ENDPOINT_SET_MESSAGE_CALLBACK
+from pyimouapi.openapi import ImouOpenApiClient
+
+
+@pytest.fixture
+def client() -> ImouOpenApiClient:
+    return ImouOpenApiClient("app_id", "app_secret", "api.example.com")
+
+
+@pytest.mark.asyncio
+async def test_set_message_callback_on(client: ImouOpenApiClient) -> None:
+    client.async_request_api = AsyncMock(return_value={})
+    await client.async_set_message_callback(
+        status="on",
+        callback_url="https://example.com/webhook",
+        callback_flag=["alarm", "deviceStatus"],
+    )
+    client.async_request_api.assert_awaited_once_with(
+        API_ENDPOINT_SET_MESSAGE_CALLBACK,
+        {
+            "status": "on",
+            "basePush": "2",
+            "callbackUrl": "https://example.com/webhook",
+            "callbackFlag": "alarm,deviceStatus",
+        },
+    )
+
+
+@pytest.mark.asyncio
+async def test_set_message_callback_off(client: ImouOpenApiClient) -> None:
+    client.async_request_api = AsyncMock(return_value={})
+    await client.async_set_message_callback(status="off")
+    client.async_request_api.assert_awaited_once_with(
+        API_ENDPOINT_SET_MESSAGE_CALLBACK,
+        {
+            "status": "off",
+            "basePush": "2",
+        },
+    )
+
+
+@pytest.mark.asyncio
+async def test_set_message_callback_on_requires_url(client: ImouOpenApiClient) -> None:
+    with pytest.raises(ValueError):
+        await client.async_set_message_callback(status="on")

pyimouapi-1.3.0/tests/test_sensor_normalize.py

@@ -0,0 +1,78 @@
+"""Tests for sensor state normalization."""
+
+from unittest.mock import AsyncMock, MagicMock
+
+import pytest
+from pyimouapi.const import (
+    PARAM_BATTERY,
+    PARAM_STATE,
+    PARAM_STATE_VARIANT,
+    PARAM_STORAGE_USED,
+    STATE_VARIANT_ENUM,
+    STATE_VARIANT_NUMERIC,
+)
+from pyimouapi.ha_device import ImouHaDevice, ImouHaDeviceManager
+from pyimouapi.sensor import apply_sensor_state, normalize_sensor_state
+
+
+@pytest.mark.parametrize(
+    ("sensor_type", "raw", "expected_state", "expected_variant"),
+    [
+        ("battery", "85", 85, STATE_VARIANT_NUMERIC),
+        ("battery", 85, 85, STATE_VARIANT_NUMERIC),
+        ("temperature_current", "23.5", 23.5, STATE_VARIANT_NUMERIC),
+        ("use_time", "120", 120, STATE_VARIANT_NUMERIC),
+        ("switch_cnt", "3", 3, STATE_VARIANT_NUMERIC),
+        ("use_electricity", "1.25", 1.25, STATE_VARIANT_NUMERIC),
+        ("storage_used", "75", 75, STATE_VARIANT_NUMERIC),
+        ("storage_used", "e1", "e1", STATE_VARIANT_ENUM),
+        ("storage_used", "e2", "e2", STATE_VARIANT_ENUM),
+        ("status", "online", "online", STATE_VARIANT_ENUM),
+        ("status", "offline", "offline", STATE_VARIANT_ENUM),
+    ],
+)
+def test_normalize_sensor_state(sensor_type, raw, expected_state, expected_variant):
+    """Normalize sensor values to typed state and variant metadata."""
+    state, variant = normalize_sensor_state(sensor_type, raw)
+    assert state == expected_state
+    assert variant == expected_variant
+
+
+def test_apply_sensor_state_writes_variant():
+    """apply_sensor_state sets PARAM_STATE and PARAM_STATE_VARIANT."""
+    sensors: dict[str, dict] = {}
+    apply_sensor_state(sensors, "battery", "90")
+    assert sensors["battery"][PARAM_STATE] == 90
+    assert sensors["battery"][PARAM_STATE_VARIANT] == STATE_VARIANT_NUMERIC
+
+
+@pytest.mark.asyncio
+async def test_update_device_battery_stores_int():
+    """Battery updates store normalized integer state."""
+    device = ImouHaDevice("d1", "cam", "Imou", "m", "1.0")
+    device.sensors[PARAM_BATTERY] = {}
+    delegate = MagicMock()
+    delegate.async_get_device_power_info = AsyncMock(
+        return_value={"electricitys": [{"litElec": "88"}]}
+    )
+    manager = ImouHaDeviceManager(delegate)
+    await manager._async_update_device_battery(device)
+    assert device.sensors[PARAM_BATTERY][PARAM_STATE] == 88
+    assert device.sensors[PARAM_BATTERY][PARAM_STATE_VARIANT] == STATE_VARIANT_NUMERIC
+
+
+@pytest.mark.asyncio
+async def test_update_device_storage_stores_int_percentage():
+    """Storage percentage is stored as int with numeric variant."""
+    device = ImouHaDevice("d1", "cam", "Imou", "m", "1.0")
+    device.sensors[PARAM_STORAGE_USED] = {}
+    delegate = MagicMock()
+    delegate.async_get_device_storage = AsyncMock(
+        return_value={"usedBytes": 50, "totalBytes": 100}
+    )
+    manager = ImouHaDeviceManager(delegate)
+    await manager._async_update_device_storage(device)
+    assert device.sensors[PARAM_STORAGE_USED][PARAM_STATE] == 50
+    assert (
+        device.sensors[PARAM_STORAGE_USED][PARAM_STATE_VARIANT] == STATE_VARIANT_NUMERIC
+    )