pyimouapi 1.3.3__tar.gz → 1.3.4__tar.gz

{pyimouapi-1.3.3 → pyimouapi-1.3.4}/PKG-INFO

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

{pyimouapi-1.3.3 → pyimouapi-1.3.4}/pyimouapi/__init__.py

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

{pyimouapi-1.3.3 → pyimouapi-1.3.4}/pyimouapi/const.py

@@ -113,6 +113,7 @@ PARAM_MOTION_DETECT = "motion_detect"
 PARAM_STORAGE_USED = "storage_used"
 PARAM_RESTART_DEVICE = "restart_device"
 PARAM_NIGHT_VISION_MODE = "night_vision_mode"
+PARAM_DEVICE_VOLUME = "device_volume"
 PARAM_COLLECTION_POINT = "collection_point"
 PARAM_COLLECTION_POINT_PROMPT = "select_collection_point"
 PARAM_SIREN_START = "siren_start"
@@ -408,31 +409,42 @@ SELECT_TYPE_REF = {
     "night_vision_mode": [
         {
             "ref": "17400",
-            "default": "0",
-            "options": ["0", "1", "2", "3"],
+            "default": "intelligent",
+            "options": ["intelligent", "fullcolor", "infrared", "off"],
             "value_type": "int",
         },
         {
             "ref": "139700",
-            "default": "0",
-            "options": ["0", "1", "2", "3", "4"],
+            "default": "intelligent",
+            "options": [
+                "intelligent",
+                "fullcolor",
+                "infrared",
+                "off",
+                "custom",
+            ],
+            "value_type": "int",
+        },
+        {
+            "ref": "112400",
+            "default": "infrared",
+            "options": ["infrared", "off"],
             "value_type": "int",
         },
-        {"ref": "112400", "default": "2", "options": ["2", "3"], "value_type": "int"},
     ],
     "mode": [
         {
             "ref": "15200",
-            "default": "0",
-            "options": ["0", "1", "2"],
+            "default": "home",
+            "options": ["home", "away", "disarm"],
             "value_type": "int",
         }
     ],
     "device_volume": [
         {
             "ref": "15400",
-            "default": "0",
-            "options": ["99", "0", "1", "2"],
+            "default": "low",
+            "options": ["mute", "low", "medium", "high"],
             "value_type": "int",
         }
     ],

{pyimouapi-1.3.3 → pyimouapi-1.3.4}/pyimouapi/ha_device.py

@@ -79,6 +79,7 @@ from .const import (
 )
 from .device import ImouDevice, ImouDeviceManager
 from .exceptions import RequestFailedException
+from .select_option import normalize_options, to_friendly, to_raw
 from .sensor import apply_sensor_state
 from .siren import build_siren_start_iot_content
 
@@ -358,16 +359,13 @@ class ImouHaDeviceManager:
         meta: dict[str, Any],
         raw_value: Any,
     ) -> None:
-        ref = meta[PARAM_REF]
         if kind == "switch":
             device.switches[key][PARAM_STATE] = raw_value == 1
         elif kind == "binary_sensor":
             device.binary_sensors[key][PARAM_STATE] = raw_value == 1
         elif kind == "select":
             value = str(raw_value) if isinstance(raw_value, int) else raw_value
-            device.selects[key][PARAM_CURRENT_OPTION] = value
-            if ref == "15400" and value == "-1":
-                device.selects[key][PARAM_CURRENT_OPTION] = "99"
+            device.selects[key][PARAM_CURRENT_OPTION] = to_friendly(key, value)
         elif kind in ("sensor", "text"):
             if meta.get(PARAM_EXPRESSION) and isinstance(raw_value, dict | list):
                 state = self.get_expression_value(meta[PARAM_EXPRESSION], raw_value)
@@ -819,6 +817,7 @@ class ImouHaDeviceManager:
                     await self.delegate.async_set_iot_device_properties(
                         device.device_id, None, device.product_id, {ref_id: value}
                     )
+                device.texts[text_type][PARAM_STATE] = str(text_value)
 
     async def async_switch_operation(
         self, device: ImouHaDevice, switch_type: str, enable: bool
@@ -865,9 +864,9 @@ class ImouHaDeviceManager:
         if device.selects[select_type].get(PARAM_REF):
             ref_id = device.selects[select_type].get(PARAM_REF)
             value_type = device.selects[select_type].get(PARAM_VALUE_TYPE)
-            write_option = option
+            write_option = to_raw(select_type, option)
             # 兼容下音量15400值为-1的情况
-            if ref_id == "15400" and option == "99":
+            if ref_id == "15400" and write_option == "99":
                 write_option = "-1"
             await self._async_select_option_by_ref(
                 device, write_option, ref_id, value_type
@@ -877,8 +876,8 @@ class ImouHaDeviceManager:
             await self.delegate.async_set_device_night_vision_mode(
                 device.device_id, device.channel_id, option
             )
-            device.selects[PARAM_NIGHT_VISION_MODE][PARAM_CURRENT_OPTION] = (
-                option.lower()
+            device.selects[PARAM_NIGHT_VISION_MODE][PARAM_CURRENT_OPTION] = to_friendly(
+                PARAM_NIGHT_VISION_MODE, option
             )
 
     async def _async_get_device_switch_status_by_ability(
@@ -922,13 +921,14 @@ class ImouHaDeviceManager:
         if PARAM_MODE not in data or PARAM_MODES not in data:
             raise RequestFailedException("get_device_night_vision fail")
         if data[PARAM_MODE] is not None:
-            device.selects[PARAM_NIGHT_VISION_MODE][PARAM_CURRENT_OPTION] = data[
-                PARAM_MODE
-            ].lower()
+            device.selects[PARAM_NIGHT_VISION_MODE][PARAM_CURRENT_OPTION] = to_friendly(
+                PARAM_NIGHT_VISION_MODE, data[PARAM_MODE]
+            )
         if data[PARAM_MODES] is not None:
-            device.selects[PARAM_NIGHT_VISION_MODE][PARAM_OPTIONS] = [
-                item.lower() for item in data[PARAM_MODES]
-            ]
+            device.selects[PARAM_NIGHT_VISION_MODE][PARAM_OPTIONS] = normalize_options(
+                PARAM_NIGHT_VISION_MODE,
+                [item.lower() for item in data[PARAM_MODES]],
+            )
 
     @staticmethod
     def configure_device_by_ability(
@@ -1337,34 +1337,6 @@ class ImouHaDeviceManager:
         except Exception as e:
             _LOGGER.error(f"_async_update_device_switch_status_by_ref fail:{e}")
 
-    async def _async_update_device_select_status_by_ref(
-        self, device: ImouHaDevice, select_type: str, ref: str
-    ):
-        try:
-            device_id = self._resolve_device_id(device)
-            data = await self.delegate.async_get_iot_device_properties(
-                device_id, device.channel_id, device.product_id, [ref]
-            )
-            if ref in data[PARAM_PROPERTIES]:
-                value = (
-                    str(data[PARAM_PROPERTIES][ref])
-                    if isinstance(data[PARAM_PROPERTIES][ref], int)
-                    else data[PARAM_PROPERTIES][ref]
-                )
-                device.selects[select_type][PARAM_CURRENT_OPTION] = value
-                if ref == "15400" and value == "-1":
-                    device.selects[select_type][PARAM_CURRENT_OPTION] = "99"
-            else:
-                self._debug_missing_property_ref(
-                    device,
-                    ref,
-                    source="getIotDeviceProperties",
-                    kind="select",
-                    key=select_type,
-                )
-        except Exception as e:
-            _LOGGER.error(f"Error while updating device select status: {e}")
-
     async def _async_update_device_sensor_status_by_ref(
         self,
         device: ImouHaDevice,
@@ -1661,11 +1633,7 @@ class ImouHaDeviceManager:
         await self.delegate.async_iot_device_control(
             device_id, device.product_id, "28600", param
         )
-        # 等待1秒，查询倒计时
-        await asyncio.sleep(1)
-        await self._async_update_device_text_status_by_ref(
-            device, "count_down_switch", device.texts["count_down_switch"]
-        )
+        device.texts["count_down_switch"][PARAM_STATE] = str(text_value)
 
 
 class DeviceStatus(Enum):

pyimouapi-1.3.4/pyimouapi/select_option.py

@@ -0,0 +1,123 @@
+"""Select option key normalization for Home Assistant integrations."""
+
+from __future__ import annotations
+
+import logging
+from typing import Any
+
+from pyimouapi.const import (
+    PARAM_COLLECTION_POINT,
+    PARAM_DEVICE_VOLUME,
+    PARAM_MODE,
+    PARAM_NIGHT_VISION_MODE,
+)
+
+_LOGGER = logging.getLogger(__name__)
+
+MAPPED_SELECT_TYPES = frozenset(
+    {PARAM_MODE, PARAM_DEVICE_VOLUME, PARAM_NIGHT_VISION_MODE}
+)
+
+# raw string -> friendly
+_VOLUME_RAW_TO_FRIENDLY = {
+    "99": "mute",
+    "-1": "mute",
+    "0": "low",
+    "1": "medium",
+    "2": "high",
+}
+_VOLUME_FRIENDLY_TO_RAW = {
+    "mute": "99",
+    "low": "0",
+    "medium": "1",
+    "high": "2",
+}
+
+_MODE_RAW_TO_FRIENDLY = {"0": "home", "1": "away", "2": "disarm"}
+_MODE_FRIENDLY_TO_RAW = {v: k for k, v in _MODE_RAW_TO_FRIENDLY.items()}
+
+_NIGHT_VISION_RAW_TO_FRIENDLY = {
+    "0": "intelligent",
+    "1": "fullcolor",
+    "2": "infrared",
+    "3": "off",
+    "4": "custom",
+}
+_NIGHT_VISION_FRIENDLY_TO_RAW = {
+    "intelligent": "0",
+    "fullcolor": "1",
+    "infrared": "2",
+    "off": "3",
+    "custom": "4",
+    "lowlight": "lowlight",
+    "smartlowlight": "smartlowlight",
+}
+# PaaS already-friendly keys also accepted as raw (identity after lower)
+for _k in (
+    "intelligent",
+    "fullcolor",
+    "infrared",
+    "off",
+    "custom",
+    "lowlight",
+    "smartlowlight",
+):
+    _NIGHT_VISION_RAW_TO_FRIENDLY.setdefault(_k, _k)
+
+
+def _as_raw_str(raw: Any) -> str:
+    if raw is None:
+        return ""
+    return str(raw).strip()
+
+
+def to_friendly(select_type: str, raw: Any) -> str:
+    """Map vendor/API raw option to a stable friendly key."""
+    if select_type == PARAM_COLLECTION_POINT or select_type not in MAPPED_SELECT_TYPES:
+        return _as_raw_str(raw)
+
+    key = _as_raw_str(raw)
+    if select_type == PARAM_DEVICE_VOLUME:
+        table = _VOLUME_RAW_TO_FRIENDLY
+    elif select_type == PARAM_MODE:
+        table = _MODE_RAW_TO_FRIENDLY
+    else:
+        key_l = key.lower()
+        mapped = _NIGHT_VISION_RAW_TO_FRIENDLY.get(key_l)
+        if mapped is not None:
+            return mapped
+        _LOGGER.debug("unknown night_vision raw option %r", raw)
+        return key_l
+
+    if key in table:
+        return table[key]
+    _LOGGER.debug("unknown %s raw option %r", select_type, raw)
+    return key
+
+
+def to_raw(select_type: str, friendly: str) -> str:
+    """Map friendly key to vendor/API raw string for IoT writes.
+
+    For PaaS-only night vision keys (`lowlight`, `smartlowlight`), returns the
+    same lowercase string (caller uses NIGHT_VISION_MODE_MAP).
+    Raises ValueError for unknown keys on mapped select types.
+    """
+    if select_type == PARAM_COLLECTION_POINT or select_type not in MAPPED_SELECT_TYPES:
+        return friendly
+
+    key = friendly.strip().lower()
+    if select_type == PARAM_DEVICE_VOLUME:
+        table = _VOLUME_FRIENDLY_TO_RAW
+    elif select_type == PARAM_MODE:
+        table = _MODE_FRIENDLY_TO_RAW
+    else:
+        table = _NIGHT_VISION_FRIENDLY_TO_RAW
+
+    if key not in table:
+        raise ValueError(f"unknown {select_type} option: {friendly!r}")
+    return table[key]
+
+
+def normalize_options(select_type: str, options: list[str]) -> list[str]:
+    """Return options list with each entry passed through to_friendly."""
+    return [to_friendly(select_type, item) for item in options]

{pyimouapi-1.3.3 → pyimouapi-1.3.4}/pyimouapi.egg-info/PKG-INFO

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

{pyimouapi-1.3.3 → pyimouapi-1.3.4}/pyimouapi.egg-info/SOURCES.txt

@@ -9,6 +9,7 @@ pyimouapi/device.py
 pyimouapi/exceptions.py
 pyimouapi/ha_device.py
 pyimouapi/openapi.py
+pyimouapi/select_option.py
 pyimouapi/sensor.py
 pyimouapi/siren.py
 pyimouapi.egg-info/PKG-INFO
@@ -23,6 +24,7 @@ tests/test_device_summaries.py
 tests/test_event_identifier_map.py
 tests/test_lookup_property.py
 tests/test_message_callback.py
+tests/test_select_option.py
 tests/test_sensor_normalize.py
 tests/test_siren.py
 tests/test_update_from_detail.py

{pyimouapi-1.3.3 → pyimouapi-1.3.4}/pyproject.toml

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

{pyimouapi-1.3.3 → pyimouapi-1.3.4}/setup.py

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

pyimouapi-1.3.4/tests/test_select_option.py

@@ -0,0 +1,111 @@
+"""Tests for select option friendly-key normalization."""
+
+from __future__ import annotations
+
+import pytest
+from pyimouapi.const import PARAM_DEVICE_VOLUME, PARAM_MODE, PARAM_NIGHT_VISION_MODE
+from pyimouapi.ha_device import ImouHaDevice, ImouHaDeviceManager
+from pyimouapi.select_option import normalize_options, to_friendly, to_raw
+
+
+@pytest.mark.parametrize(
+    ("select_type", "raw", "friendly"),
+    [
+        (PARAM_DEVICE_VOLUME, "99", "mute"),
+        (PARAM_DEVICE_VOLUME, "-1", "mute"),
+        (PARAM_DEVICE_VOLUME, -1, "mute"),
+        (PARAM_DEVICE_VOLUME, "0", "low"),
+        (PARAM_DEVICE_VOLUME, "1", "medium"),
+        (PARAM_DEVICE_VOLUME, "2", "high"),
+        (PARAM_MODE, "0", "home"),
+        (PARAM_MODE, "1", "away"),
+        (PARAM_MODE, "2", "disarm"),
+        (PARAM_NIGHT_VISION_MODE, "0", "intelligent"),
+        (PARAM_NIGHT_VISION_MODE, "1", "fullcolor"),
+        (PARAM_NIGHT_VISION_MODE, "2", "infrared"),
+        (PARAM_NIGHT_VISION_MODE, "3", "off"),
+        (PARAM_NIGHT_VISION_MODE, "4", "custom"),
+        (PARAM_NIGHT_VISION_MODE, "intelligent", "intelligent"),
+        (PARAM_NIGHT_VISION_MODE, "FullColor", "fullcolor"),
+        (PARAM_NIGHT_VISION_MODE, "lowlight", "lowlight"),
+        (PARAM_NIGHT_VISION_MODE, "smartlowlight", "smartlowlight"),
+    ],
+)
+def test_to_friendly(select_type: str, raw: str | int, friendly: str) -> None:
+    assert to_friendly(select_type, raw) == friendly
+
+
+@pytest.mark.parametrize(
+    ("select_type", "friendly", "raw"),
+    [
+        (PARAM_DEVICE_VOLUME, "mute", "99"),
+        (PARAM_DEVICE_VOLUME, "low", "0"),
+        (PARAM_DEVICE_VOLUME, "medium", "1"),
+        (PARAM_DEVICE_VOLUME, "high", "2"),
+        (PARAM_MODE, "home", "0"),
+        (PARAM_MODE, "away", "1"),
+        (PARAM_MODE, "disarm", "2"),
+        (PARAM_NIGHT_VISION_MODE, "intelligent", "0"),
+        (PARAM_NIGHT_VISION_MODE, "fullcolor", "1"),
+        (PARAM_NIGHT_VISION_MODE, "infrared", "2"),
+        (PARAM_NIGHT_VISION_MODE, "off", "3"),
+        (PARAM_NIGHT_VISION_MODE, "custom", "4"),
+        (PARAM_NIGHT_VISION_MODE, "lowlight", "lowlight"),
+        (PARAM_NIGHT_VISION_MODE, "smartlowlight", "smartlowlight"),
+    ],
+)
+def test_to_raw(select_type: str, friendly: str, raw: str) -> None:
+    assert to_raw(select_type, friendly) == raw
+
+
+def test_to_friendly_unknown_raw_passthrough() -> None:
+    assert to_friendly(PARAM_MODE, "9") == "9"
+
+
+def test_to_raw_unknown_friendly_raises() -> None:
+    with pytest.raises(ValueError, match="unknown"):
+        to_raw(PARAM_MODE, "vacation")
+
+
+def test_normalize_options_maps_list() -> None:
+    assert normalize_options(PARAM_MODE, ["0", "1", "2"]) == [
+        "home",
+        "away",
+        "disarm",
+    ]
+
+
+def test_collection_point_identity() -> None:
+    from pyimouapi.const import PARAM_COLLECTION_POINT
+
+    assert to_friendly(PARAM_COLLECTION_POINT, "door") == "door"
+    assert to_raw(PARAM_COLLECTION_POINT, "door") == "door"
+
+
+def test_configure_select_by_ref_uses_friendly_defaults() -> None:
+    device = ImouHaDevice("d1", "cam", "Imou", "IPC", "1.0")
+    device.set_channel_id("0")
+    device.set_product_id("pid")
+    # refs that match SELECT_TYPE_REF entries
+    ImouHaDeviceManager.configure_select_by_ref(
+        ["15200", "15400", "17400"],
+        True,
+        [],
+        device,
+    )
+    assert device.selects[PARAM_MODE]["options"] == ["home", "away", "disarm"]
+    assert device.selects[PARAM_MODE]["current_option"] == "home"
+    assert device.selects[PARAM_DEVICE_VOLUME]["options"] == [
+        "mute",
+        "low",
+        "medium",
+        "high",
+    ]
+    assert device.selects[PARAM_DEVICE_VOLUME]["current_option"] == "low"
+    assert device.selects[PARAM_NIGHT_VISION_MODE]["options"] == [
+        "intelligent",
+        "fullcolor",
+        "infrared",
+        "off",
+    ]
+    assert device.selects[PARAM_NIGHT_VISION_MODE]["current_option"] == "intelligent"

{pyimouapi-1.3.3 → pyimouapi-1.3.4}/tests/test_update_from_detail.py

@@ -6,6 +6,7 @@ import pytest
 from pyimouapi.const import (
     PARAM_CHANNELS,
     PARAM_CURRENT_OPTION,
+    PARAM_DEVICE_VOLUME,
     PARAM_ONLINE,
     PARAM_PROPERTIES,
     PARAM_REF,
@@ -26,7 +27,10 @@ def _online_device() -> ImouHaDevice:
 async def test_update_from_detail_applies_switch_and_select():
     device = _online_device()
     device.switches["relay"] = {PARAM_REF: "10001", PARAM_STATE: False}
-    device.selects["volume"] = {PARAM_REF: "15400", PARAM_CURRENT_OPTION: "0"}
+    device.selects[PARAM_DEVICE_VOLUME] = {
+        PARAM_REF: "15400",
+        PARAM_CURRENT_OPTION: "low",
+    }
 
     detail = {
         PARAM_PROPERTIES: {"10001": 1, "15400": -1},
@@ -39,7 +43,7 @@ async def test_update_from_detail_applies_switch_and_select():
     await manager._async_update_properties_from_detail(device, detail)
 
     assert device.switches["relay"][PARAM_STATE] is True
-    assert device.selects["volume"][PARAM_CURRENT_OPTION] == "99"
+    assert device.selects[PARAM_DEVICE_VOLUME][PARAM_CURRENT_OPTION] == "mute"
 
 
 @pytest.mark.asyncio

pyimouapi-1.3.4/tests/test_write_optimistic_state.py

@@ -0,0 +1,127 @@
+"""Tests for optimistic local state after writes (no post-write cloud read)."""
+
+from __future__ import annotations
+
+from unittest.mock import AsyncMock, MagicMock
+
+import pytest
+from pyimouapi.const import (
+    PARAM_CURRENT_OPTION,
+    PARAM_DEVICE_VOLUME,
+    PARAM_MODE,
+    PARAM_OPTIONS,
+    PARAM_REF,
+    PARAM_STATE,
+    PARAM_VALUE_TYPE,
+)
+from pyimouapi.ha_device import ImouHaDevice, ImouHaDeviceManager
+
+
+def _ha_device(*, product_id: str | None = "prod1") -> ImouHaDevice:
+    device = ImouHaDevice("DEV001", "Camera", "Imou", "IPC", "1.0")
+    device.set_channel_id("0")
+    if product_id is not None:
+        device.set_product_id(product_id)
+    return device
+
+
+@pytest.mark.asyncio
+async def test_switch_operation_by_ref_updates_local_state_without_read() -> None:
+    """IoT switch writes update local state without getIotDeviceProperties."""
+    device = _ha_device()
+    device.switches["motion_detect"] = {PARAM_REF: "12300", PARAM_STATE: False}
+    delegate = MagicMock()
+    delegate.async_set_iot_device_properties = AsyncMock()
+    delegate.async_get_iot_device_properties = AsyncMock()
+    manager = ImouHaDeviceManager(delegate)
+
+    await manager.async_switch_operation(device, "motion_detect", True)
+
+    assert device.switches["motion_detect"][PARAM_STATE] is True
+    delegate.async_get_iot_device_properties.assert_not_called()
+
+
+@pytest.mark.asyncio
+async def test_select_option_by_ref_updates_local_state_without_read() -> None:
+    """IoT select writes update current_option without a coordinator refresh read."""
+    device = _ha_device()
+    device.selects[PARAM_MODE] = {
+        PARAM_REF: "15200",
+        PARAM_CURRENT_OPTION: "home",
+        PARAM_OPTIONS: ["home", "away", "disarm"],
+        PARAM_VALUE_TYPE: "int",
+    }
+    delegate = MagicMock()
+    delegate.async_set_iot_device_properties = AsyncMock()
+    delegate.async_get_iot_device_properties = AsyncMock()
+    manager = ImouHaDeviceManager(delegate)
+
+    await manager.async_select_option(device, PARAM_MODE, "away")
+
+    assert device.selects[PARAM_MODE][PARAM_CURRENT_OPTION] == "away"
+    props = delegate.async_set_iot_device_properties.await_args.args[3]
+    assert props == {"15200": 1}
+    delegate.async_get_iot_device_properties.assert_not_called()
+
+
+@pytest.mark.asyncio
+async def test_select_volume_mute_writes_minus_one() -> None:
+    device = _ha_device()
+    device.selects[PARAM_DEVICE_VOLUME] = {
+        PARAM_REF: "15400",
+        PARAM_CURRENT_OPTION: "low",
+        PARAM_OPTIONS: ["mute", "low", "medium", "high"],
+        PARAM_VALUE_TYPE: "int",
+    }
+    delegate = MagicMock()
+    delegate.async_set_iot_device_properties = AsyncMock()
+    manager = ImouHaDeviceManager(delegate)
+
+    await manager.async_select_option(device, PARAM_DEVICE_VOLUME, "mute")
+
+    assert device.selects[PARAM_DEVICE_VOLUME][PARAM_CURRENT_OPTION] == "mute"
+    props = delegate.async_set_iot_device_properties.await_args.args[3]
+    assert props == {"15400": -1}
+
+
+@pytest.mark.asyncio
+async def test_set_text_value_by_ref_updates_local_state_without_read() -> None:
+    """IoT text writes update local state without getIotDeviceProperties."""
+    device = _ha_device()
+    device.texts["overcharge_switch"] = {
+        PARAM_REF: "128900",
+        PARAM_STATE: "5",
+        PARAM_VALUE_TYPE: "int",
+    }
+    delegate = MagicMock()
+    delegate.async_set_iot_device_properties = AsyncMock()
+    delegate.async_get_iot_device_properties = AsyncMock()
+    manager = ImouHaDeviceManager(delegate)
+
+    await manager.async_set_text_value(device, "overcharge_switch", "100")
+
+    assert device.texts["overcharge_switch"][PARAM_STATE] == "100"
+    delegate.async_get_iot_device_properties.assert_not_called()
+
+
+@pytest.mark.asyncio
+async def test_set_count_down_text_updates_local_state_without_read() -> None:
+    """Countdown text writes update local state without sleep/re-query."""
+    device = _ha_device()
+    device.switches["switch"] = {PARAM_REF: "10000", PARAM_STATE: False}
+    device.texts["count_down_switch"] = {
+        PARAM_REF: "28800",
+        PARAM_STATE: "0",
+    }
+    delegate = MagicMock()
+    delegate.async_iot_device_control = AsyncMock()
+    delegate.async_get_iot_device_properties = AsyncMock()
+    manager = ImouHaDeviceManager(delegate)
+    manager._async_update_device_switch_status_by_ref = AsyncMock()
+
+    await manager.async_set_text_value(device, "count_down_switch", "10")
+
+    assert device.texts["count_down_switch"][PARAM_STATE] == "10"
+    manager._async_update_device_switch_status_by_ref.assert_awaited_once()
+    delegate.async_iot_device_control.assert_awaited_once()
+    delegate.async_get_iot_device_properties.assert_not_called()

pyimouapi-1.3.3/tests/test_write_optimistic_state.py

@@ -1,60 +0,0 @@
-"""Tests for optimistic local state after writes (no post-write cloud read)."""
-
-from __future__ import annotations
-
-from unittest.mock import AsyncMock, MagicMock
-
-import pytest
-from pyimouapi.const import (
-    PARAM_CURRENT_OPTION,
-    PARAM_MODE,
-    PARAM_OPTIONS,
-    PARAM_REF,
-    PARAM_STATE,
-    PARAM_VALUE_TYPE,
-)
-from pyimouapi.ha_device import ImouHaDevice, ImouHaDeviceManager
-
-
-def _ha_device(*, product_id: str | None = "prod1") -> ImouHaDevice:
-    device = ImouHaDevice("DEV001", "Camera", "Imou", "IPC", "1.0")
-    device.set_channel_id("0")
-    if product_id is not None:
-        device.set_product_id(product_id)
-    return device
-
-
-@pytest.mark.asyncio
-async def test_switch_operation_by_ref_updates_local_state_without_read() -> None:
-    """IoT switch writes update local state without getIotDeviceProperties."""
-    device = _ha_device()
-    device.switches["motion_detect"] = {PARAM_REF: "12300", PARAM_STATE: False}
-    delegate = MagicMock()
-    delegate.async_set_iot_device_properties = AsyncMock()
-    delegate.async_get_iot_device_properties = AsyncMock()
-    manager = ImouHaDeviceManager(delegate)
-
-    await manager.async_switch_operation(device, "motion_detect", True)
-
-    assert device.switches["motion_detect"][PARAM_STATE] is True
-    delegate.async_get_iot_device_properties.assert_not_called()
-
-
-@pytest.mark.asyncio
-async def test_select_option_by_ref_updates_local_state_without_read() -> None:
-    """IoT select writes update current_option without a coordinator refresh read."""
-    device = _ha_device()
-    device.selects[PARAM_MODE] = {
-        PARAM_REF: "15200",
-        PARAM_CURRENT_OPTION: "0",
-        PARAM_OPTIONS: ["0", "1", "2"],
-        PARAM_VALUE_TYPE: "int",
-    }
-    delegate = MagicMock()
-    delegate.async_set_iot_device_properties = AsyncMock()
-    manager = ImouHaDeviceManager(delegate)
-
-    await manager.async_select_option(device, PARAM_MODE, "1")
-
-    assert device.selects[PARAM_MODE][PARAM_CURRENT_OPTION] == "1"
-    delegate.async_get_iot_device_properties.assert_not_called()