pyimouapi 1.3.0__tar.gz → 1.3.2__tar.gz

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

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

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

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

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

@@ -93,6 +93,8 @@ PARAM_URL = "url"
 PARAM_KEY = "key"
 PARAM_DEFAULT = "default"
 PARAM_REF = "ref"
+PARAM_EVENTS = "events"
+PARAM_IDENTIFIER = "identifier"
 PARAM_CONTENT = "content"
 PARAM_ON = "on"
 PARAM_BUTTON_TYPE_REF = "button_type_ref"

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

@@ -1,5 +1,7 @@
 from __future__ import annotations
 
+import asyncio
+import logging
 from dataclasses import dataclass
 from typing import Any
 
@@ -49,6 +51,8 @@ from .const import (
     PARAM_DURATION,
     PARAM_ENABLE,
     PARAM_ENABLE_TYPE,
+    PARAM_EVENTS,
+    PARAM_IDENTIFIER,
     PARAM_MODE,
     PARAM_MULTI_FLAG,
     PARAM_OPERATION,
@@ -64,6 +68,27 @@ from .const import (
 )
 from .openapi import ImouOpenApiClient
 
+_LOGGER = logging.getLogger(__name__)
+
+
+def _parse_event_ref_map(data: dict[str, Any] | None) -> dict[str, str]:
+    """Build {event.ref: event.identifier} from a getProductModel payload."""
+    if not isinstance(data, dict):
+        return {}
+    events = data.get(PARAM_EVENTS)
+    if not isinstance(events, list):
+        return {}
+    mapping: dict[str, str] = {}
+    for item in events:
+        if not isinstance(item, dict):
+            continue
+        ref = item.get(PARAM_REF)
+        identifier = item.get(PARAM_IDENTIFIER)
+        if ref is None or identifier is None or identifier == "":
+            continue
+        mapping[str(ref)] = str(identifier)
+    return mapping
+
 
 @dataclass(frozen=True)
 class ImouDeviceSummary:
@@ -229,6 +254,54 @@ class ImouDevice:
 class ImouDeviceManager:
     def __init__(self, imou_api_client: ImouOpenApiClient):
         self._imou_api_client = imou_api_client
+        self._event_maps: dict[str, dict[str, str]] = {}
+        self._event_map_locks: dict[str, asyncio.Lock] = {}
+        self._event_map_locks_guard = asyncio.Lock()
+
+    async def async_close(self) -> None:
+        """Close the underlying Open API HTTP session."""
+        await self._imou_api_client.async_close()
+
+    async def _async_lock_for_product(self, product_id: str) -> asyncio.Lock:
+        async with self._event_map_locks_guard:
+            lock = self._event_map_locks.get(product_id)
+            if lock is None:
+                lock = asyncio.Lock()
+                self._event_map_locks[product_id] = lock
+            return lock
+
+    async def async_ensure_event_map(self, product_id: str) -> None:
+        """Fetch and cache events ref→identifier for product_id if missing."""
+        if not product_id:
+            return
+        if product_id in self._event_maps:
+            return
+        lock = await self._async_lock_for_product(product_id)
+        async with lock:
+            if product_id in self._event_maps:
+                return
+            try:
+                data = await self.async_get_product_model(product_id)
+            except Exception:
+                _LOGGER.warning(
+                    "getProductModel failed for product_id=%s",
+                    product_id,
+                    exc_info=True,
+                )
+                return
+            self._event_maps[product_id] = _parse_event_ref_map(data)
+
+    async def async_resolve_event_identifier(
+        self, product_id: str, ref: str
+    ) -> str | None:
+        """Return event identifier for ref, fetching the product model if needed."""
+        if not product_id or ref is None or ref == "":
+            return None
+        await self.async_ensure_event_map(product_id)
+        mapping = self._event_maps.get(product_id)
+        if mapping is None:
+            return None
+        return mapping.get(str(ref))
 
     async def async_get_devices(
         self, page: int = 1, page_size: int = 10
@@ -486,11 +559,13 @@ class ImouDeviceManager:
                 }
             ]
         }
-        return (
-            await self._imou_api_client.async_request_api(
-                API_ENDPOINT_GET_IOT_DEVICE_PROPERTIES, params
-            )
-        ).get(PARAM_DEVICE_LIST, [{}])[0]
+        data = await self._imou_api_client.async_request_api(
+            API_ENDPOINT_GET_IOT_DEVICE_PROPERTIES, params
+        )
+        device_list = data.get(PARAM_DEVICE_LIST) if isinstance(data, dict) else None
+        if not device_list:
+            return {}
+        return device_list[0]
 
     async def async_set_iot_device_properties(
         self, device_id: str, channel_id: str | None, product_id: str, properties: dict
@@ -586,12 +661,15 @@ class ImouDeviceManager:
         if device_detail.get(PARAM_CHANNELS) and imou_device.channels:
             channels_detail = device_detail.get(PARAM_CHANNELS)
             channel_detail_map = {
-                channel_detail.get(PARAM_CHANNEL_ID): channel_detail.get(
+                str(channel_detail.get(PARAM_CHANNEL_ID)): channel_detail.get(
                     PARAM_ABILITY_REFS, "unknown"
                 )
                 for channel_detail in channels_detail
+                if channel_detail.get(PARAM_CHANNEL_ID) is not None
             }
             for channel in imou_device.channels:
-                channel_id = channel.channel_id
-                if channel_id in channel_detail_map:
+                channel_id = (
+                    str(channel.channel_id) if channel.channel_id is not None else None
+                )
+                if channel_id is not None and channel_id in channel_detail_map:
                     channel.set_channel_ability_refs(channel_detail_map[channel_id])

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

@@ -254,6 +254,10 @@ class ImouHaDeviceManager:
     def delegate(self):
         return self._delegate
 
+    async def async_close(self) -> None:
+        """Close the underlying Open API HTTP session."""
+        await self._delegate.async_close()
+
     @staticmethod
     def _resolve_device_id(device: ImouHaDevice) -> str:
         device_id = device.device_id
@@ -482,8 +486,11 @@ class ImouHaDeviceManager:
                     self.get_device_status(data[PARAM_ONLINE]),
                 )
             else:
+                device_channel_id = (
+                    str(device.channel_id) if device.channel_id is not None else None
+                )
                 for channel in data[PARAM_CHANNELS]:
-                    if channel[PARAM_CHANNEL_ID] == device.channel_id:
+                    if str(channel[PARAM_CHANNEL_ID]) == device_channel_id:
                         apply_sensor_state(
                             device.sensors,
                             PARAM_STATUS,
@@ -681,9 +688,12 @@ class ImouHaDeviceManager:
                         + "_"
                         + device.parent_product_id
                     )
-                if value_type == "int" and text_value.isdigit():
-                    value = int(text_value)
-                elif value_type == "str" and not isinstance(value_type, str):
+                if value_type == "int":
+                    try:
+                        value = int(text_value)
+                    except (TypeError, ValueError):
+                        value = text_value
+                elif value_type == "str":
                     value = str(text_value)
                 else:
                     value = text_value

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

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

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

@@ -14,8 +14,10 @@ pyimouapi.egg-info/SOURCES.txt
 pyimouapi.egg-info/dependency_links.txt
 pyimouapi.egg-info/requires.txt
 pyimouapi.egg-info/top_level.txt
+tests/test_channel_id_and_api_guards.py
 tests/test_collect_property_entities.py
 tests/test_device_summaries.py
+tests/test_event_identifier_map.py
 tests/test_lookup_property.py
 tests/test_message_callback.py
 tests/test_sensor_normalize.py

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

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

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

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

pyimouapi-1.3.2/tests/test_channel_id_and_api_guards.py

@@ -0,0 +1,97 @@
+"""Guards for channelId type mismatch and empty API payloads."""
+
+from unittest.mock import AsyncMock, MagicMock
+
+import pytest
+from pyimouapi.const import (
+    PARAM_ABILITY_REFS,
+    PARAM_CHANNEL_ID,
+    PARAM_CHANNELS,
+    PARAM_DEVICE_LIST,
+    PARAM_ONLINE,
+    PARAM_REF,
+    PARAM_STATE,
+    PARAM_STATUS,
+    PARAM_VALUE_TYPE,
+)
+from pyimouapi.device import ImouChannel, ImouDevice, ImouDeviceManager
+from pyimouapi.ha_device import DeviceStatus, ImouHaDevice, ImouHaDeviceManager
+
+
+@pytest.mark.asyncio
+async def test_online_status_matches_int_channel_id():
+    """API may return channelId as int while HA device stores str."""
+    device = ImouHaDevice("dev1", "Cam", "Imou", "IPC", "1.0")
+    device.set_channel_id("0")
+    device.sensors[PARAM_STATUS][PARAM_STATE] = DeviceStatus.OFFLINE.value
+
+    delegate = MagicMock()
+    delegate.async_get_device_online_status = AsyncMock(
+        return_value={
+            PARAM_ONLINE: "1",
+            PARAM_CHANNELS: [
+                {PARAM_CHANNEL_ID: 0, PARAM_ONLINE: "1"},
+            ],
+        }
+    )
+    manager = ImouHaDeviceManager(delegate)
+    await manager._async_update_status(device)
+
+    assert device.sensors[PARAM_STATUS][PARAM_STATE] == DeviceStatus.ONLINE.value
+
+
+@pytest.mark.asyncio
+async def test_ability_refs_match_int_channel_id():
+    """Channel abilityRefs lookup must tolerate int/str channelId."""
+    channel = ImouChannel("0", "ch0", "1", "ability")
+    device = ImouDevice("dev1", "Cam", "1", "Imou", "IPC")
+    device.set_channels([channel])
+    device.set_product_id("pid1")
+
+    manager = ImouDeviceManager(MagicMock())
+    manager.async_get_iot_device_detail_info = AsyncMock(
+        return_value={
+            PARAM_ABILITY_REFS: "devAbility",
+            PARAM_CHANNELS: [
+                {PARAM_CHANNEL_ID: 0, PARAM_ABILITY_REFS: "chAbility"},
+            ],
+        }
+    )
+    await manager._async_update_device_ability_refs(device)
+
+    assert channel.channel_ability_refs == "chAbility"
+
+
+@pytest.mark.asyncio
+async def test_get_iot_device_properties_empty_list():
+    """Empty deviceList must not raise IndexError."""
+    api = MagicMock()
+    api.async_request_api = AsyncMock(return_value={PARAM_DEVICE_LIST: []})
+    manager = ImouDeviceManager(api)
+
+    result = await manager.async_get_iot_device_properties(
+        "dev1", "0", "pid", ["10001"]
+    )
+    assert result == {}
+
+
+@pytest.mark.asyncio
+async def test_set_text_value_coerces_str_type():
+    """value_type=str must stringify the payload."""
+    device = ImouHaDevice("dev1", "Plug", "Imou", "Plug", "1.0")
+    device.set_product_id("pid1")
+    device.texts["name"] = {
+        PARAM_REF: "20001",
+        PARAM_VALUE_TYPE: "str",
+        PARAM_STATE: "",
+    }
+
+    delegate = MagicMock()
+    delegate.async_set_iot_device_properties = AsyncMock()
+    manager = ImouHaDeviceManager(delegate)
+
+    await manager.async_set_text_value(device, "name", "hello")
+
+    delegate.async_set_iot_device_properties.assert_awaited_with(
+        "dev1", None, "pid1", {"20001": "hello"}
+    )

pyimouapi-1.3.2/tests/test_event_identifier_map.py

@@ -0,0 +1,94 @@
+"""Tests for product-model event ref → identifier mapping."""
+
+from unittest.mock import AsyncMock, MagicMock
+
+import pytest
+from pyimouapi.const import API_ENDPOINT_GET_PRODUCT_MODEL, PARAM_PRODUCT_ID
+from pyimouapi.device import ImouDeviceManager, _parse_event_ref_map
+from pyimouapi.exceptions import RequestFailedException
+
+
+def test_parse_event_ref_map_extracts_events_only():
+    data = {
+        "events": [
+            {"ref": "33000", "identifier": "doorOpen", "name": "Door"},
+            {"ref": 123900, "identifier": "electricity"},
+            {"identifier": "missingRef"},
+            {"ref": "999", "identifier": ""},
+            {"ref": "1"},
+        ],
+        "properties": [{"ref": "1", "identifier": "battery"}],
+    }
+    assert _parse_event_ref_map(data) == {
+        "33000": "doorOpen",
+        "123900": "electricity",
+    }
+
+
+def test_parse_event_ref_map_missing_events():
+    assert _parse_event_ref_map({}) == {}
+    assert _parse_event_ref_map({"events": "bad"}) == {}
+
+
+@pytest.mark.asyncio
+async def test_ensure_event_map_fetches_once_and_caches():
+    client = MagicMock()
+    client.async_request_api = AsyncMock(
+        return_value={
+            "events": [{"ref": "33000", "identifier": "doorOpen"}],
+        }
+    )
+    manager = ImouDeviceManager(client)
+
+    await manager.async_ensure_event_map("pidA")
+    await manager.async_ensure_event_map("pidA")
+
+    assert client.async_request_api.await_count == 1
+    client.async_request_api.assert_awaited_with(
+        API_ENDPOINT_GET_PRODUCT_MODEL,
+        {PARAM_PRODUCT_ID: "pidA"},
+    )
+    assert await manager.async_resolve_event_identifier("pidA", "33000") == "doorOpen"
+    assert await manager.async_resolve_event_identifier("pidA", "missing") is None
+
+
+@pytest.mark.asyncio
+async def test_ensure_event_map_failure_does_not_poison_cache():
+    client = MagicMock()
+    client.async_request_api = AsyncMock(
+        side_effect=[
+            RequestFailedException("boom"),
+            {"events": [{"ref": "1", "identifier": "ok"}]},
+        ]
+    )
+    manager = ImouDeviceManager(client)
+
+    await manager.async_ensure_event_map("pidB")
+    assert await manager.async_resolve_event_identifier("pidB", "1") == "ok"
+    assert client.async_request_api.await_count == 2
+
+
+@pytest.mark.asyncio
+async def test_ensure_event_map_single_flight():
+    import asyncio
+
+    client = MagicMock()
+    started = asyncio.Event()
+    release = asyncio.Event()
+
+    async def slow_request(endpoint, params):
+        started.set()
+        await release.wait()
+        return {"events": [{"ref": "9", "identifier": "once"}]}
+
+    client.async_request_api = AsyncMock(side_effect=slow_request)
+    manager = ImouDeviceManager(client)
+
+    t1 = asyncio.create_task(manager.async_ensure_event_map("pidC"))
+    await started.wait()
+    t2 = asyncio.create_task(manager.async_ensure_event_map("pidC"))
+    await asyncio.sleep(0)
+    release.set()
+    await asyncio.gather(t1, t2)
+
+    assert client.async_request_api.await_count == 1