pyimouapi 1.3.2__tar.gz → 1.3.3__tar.gz

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: pyimouapi
-Version: 1.3.2
+Version: 1.3.3
 Summary: A package for imou open api
 Home-page: https://github.com/Imou-OpenPlatform/Py-Imou-Open-Api
 Author: Imou-OpenPlatform
@@ -30,8 +30,9 @@ Async Python client for the **Imou Open Platform** cloud APIs. Built on **aiohtt
 | Module | Role |
 |--------|------|
 | `pyimouapi.openapi` | `ImouOpenApiClient` — auth, signing, token lifecycle, HTTP calls |
-| `pyimouapi.device` | `ImouDeviceManager`, `ImouDevice`, `ImouChannel` — listing, PTZ, alarms, storage, and related endpoints |
-| `pyimouapi.ha_device` | `ImouHaDeviceManager`, `ImouHaDevice`, … — aggregated “device model” helpers for automation stacks |
+| `pyimouapi.device` | `ImouDeviceManager`, `ImouDevice`, `ImouChannel` — listing, PTZ, alarms, storage, collection points (`getCollection` / `turnCollection`), and related endpoints |
+| `pyimouapi.collection_point` | Parsing helpers for PaaS / IoT collection point (preset) name lists |
+| `pyimouapi.ha_device` | `ImouHaDeviceManager`, `ImouHaDevice`, … — aggregated “device model” helpers for automation stacks (including `select.collection_point` when the device exposes `CollectionPoint` or IoT refs `21500`/`22000`) |
 | `pyimouapi.exceptions` | `ImouException` and typed errors (connect, request, invalid credentials, …) |
 
 The top-level `pyimouapi` package re-exports common symbols. Import submodules directly when needed, for example `from pyimouapi.ha_device import ImouHaDeviceManager`.

{pyimouapi-1.3.2 → pyimouapi-1.3.3}/README.md

@@ -11,8 +11,9 @@ Async Python client for the **Imou Open Platform** cloud APIs. Built on **aiohtt
 | Module | Role |
 |--------|------|
 | `pyimouapi.openapi` | `ImouOpenApiClient` — auth, signing, token lifecycle, HTTP calls |
-| `pyimouapi.device` | `ImouDeviceManager`, `ImouDevice`, `ImouChannel` — listing, PTZ, alarms, storage, and related endpoints |
-| `pyimouapi.ha_device` | `ImouHaDeviceManager`, `ImouHaDevice`, … — aggregated “device model” helpers for automation stacks |
+| `pyimouapi.device` | `ImouDeviceManager`, `ImouDevice`, `ImouChannel` — listing, PTZ, alarms, storage, collection points (`getCollection` / `turnCollection`), and related endpoints |
+| `pyimouapi.collection_point` | Parsing helpers for PaaS / IoT collection point (preset) name lists |
+| `pyimouapi.ha_device` | `ImouHaDeviceManager`, `ImouHaDevice`, … — aggregated “device model” helpers for automation stacks (including `select.collection_point` when the device exposes `CollectionPoint` or IoT refs `21500`/`22000`) |
 | `pyimouapi.exceptions` | `ImouException` and typed errors (connect, request, invalid credentials, …) |
 
 The top-level `pyimouapi` package re-exports common symbols. Import submodules directly when needed, for example `from pyimouapi.ha_device import ImouHaDeviceManager`.

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

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

pyimouapi-1.3.3/pyimouapi/collection_point.py

@@ -0,0 +1,89 @@
+"""Collection point (PTZ preset) parsing helpers."""
+
+from __future__ import annotations
+
+from typing import Any
+
+from .const import IOT_COLLECTION_NAME_REF, PARAM_COLLECTION_POINT_PROMPT
+
+
+def parse_paas_collection_names(data: dict[str, Any]) -> list[str]:
+    """Extract preset names from getCollection PaaS response data."""
+    names: list[str] = []
+    for item in data.get("collections") or []:
+        if not isinstance(item, dict):
+            continue
+        name = item.get("name")
+        if name and str(name) != PARAM_COLLECTION_POINT_PROMPT:
+            names.append(str(name))
+    return unique_preserve_order(names)
+
+
+def _name_from_collection_item(item: dict[str, Any]) -> str | None:
+    for key in ("Name", "name", IOT_COLLECTION_NAME_REF):
+        value = item.get(key)
+        if value:
+            return str(value)
+    return None
+
+
+def parse_iot_collection_names(output_data: Any) -> list[str]:
+    """Extract preset names from GetCollection IoT outputData."""
+    names: list[str] = []
+    if output_data is None:
+        return names
+
+    if isinstance(output_data, dict):
+        for value in output_data.values():
+            if isinstance(value, list):
+                names.extend(_names_from_collection_items(value))
+            elif isinstance(value, str) and value != PARAM_COLLECTION_POINT_PROMPT:
+                names.append(value)
+        return unique_preserve_order(names)
+
+    if isinstance(output_data, list):
+        if output_data and all(isinstance(item, dict) for item in output_data):
+            if any(
+                item.get("identifier") == "collection"
+                or IOT_COLLECTION_NAME_REF in item
+                or "Name" in item
+                for item in output_data
+            ):
+                names.extend(_names_from_collection_items(output_data))
+            else:
+                for item in output_data:
+                    if not isinstance(item, dict):
+                        continue
+                    nested = item.get("value")
+                    if isinstance(nested, list):
+                        names.extend(_names_from_collection_items(nested))
+        return unique_preserve_order(names)
+
+    return names
+
+
+def _names_from_collection_items(items: list[Any]) -> list[str]:
+    names: list[str] = []
+    for item in items:
+        if not isinstance(item, dict):
+            continue
+        name = _name_from_collection_item(item)
+        if name and name != PARAM_COLLECTION_POINT_PROMPT:
+            names.append(name)
+    return names
+
+
+def unique_preserve_order(names: list[str]) -> list[str]:
+    seen: set[str] = set()
+    ordered: list[str] = []
+    for name in names:
+        if name in seen:
+            continue
+        seen.add(name)
+        ordered.append(name)
+    return ordered
+
+
+def build_collection_point_options(names: list[str]) -> list[str]:
+    """Build select options with placeholder first, preserving API order."""
+    return [PARAM_COLLECTION_POINT_PROMPT, *unique_preserve_order(names)]

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

@@ -23,6 +23,10 @@ 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"
+API_ENDPOINT_GET_COLLECTION = "/openapi/getCollection"
+API_ENDPOINT_TURN_COLLECTION = "/openapi/turnCollection"
+API_ENDPOINT_SIREN_START = "/openapi/sirenStart"
+API_ENDPOINT_SIREN_STOP = "/openapi/sirenStop"
 
 # error_codes
 ERROR_CODE_SUCCESS = "0"
@@ -109,6 +113,10 @@ PARAM_MOTION_DETECT = "motion_detect"
 PARAM_STORAGE_USED = "storage_used"
 PARAM_RESTART_DEVICE = "restart_device"
 PARAM_NIGHT_VISION_MODE = "night_vision_mode"
+PARAM_COLLECTION_POINT = "collection_point"
+PARAM_COLLECTION_POINT_PROMPT = "select_collection_point"
+PARAM_SIREN_START = "siren_start"
+PARAM_SIREN_STOP = "siren_stop"
 PARAM_PTZ = "ptz"
 PARAM_TEMPERATURE_CURRENT = "temperature_current"
 PARAM_HUMIDITY_CURRENT = "humidity_current"
@@ -128,6 +136,18 @@ PARAM_ABILITY_REFS = "abilityRefs"
 PARAM_REF_TYPE = "ref_type"
 PARAM_EXPRESSION = "expression"
 PARAM_OUTPUT_DATA = "outputData"
+PARAM_TURN_REF = "turn_ref"
+PARAM_TURN_INPUT_REF = "turn_input_ref"
+PARAM_INPUT_REF = "input_ref"
+PARAM_COLLECTION_NAME = "name"
+
+IOT_GET_COLLECTION_REF = "21500"
+IOT_TURN_COLLECTION_REF = "22000"
+IOT_TURN_COLLECTION_NAME_REF = "22001"
+IOT_COLLECTION_NAME_REF = "21551"
+IOT_SIREN_START_REF = "25500"
+IOT_SIREN_START_INPUT_REF = "25501"
+IOT_SIREN_STOP_REF = "22200"
 PARAM_VALUE_TYPE = "value_type"
 PARAM_ACCESS_TYPE = "accessType"
 PARAM_ABILITY = "ability"
@@ -294,6 +314,8 @@ SWITCH_TYPE_REF = {
 #  Required capacity for various button types
 BUTTON_TYPE_ABILITY = {
     "restart_device": ["Reboot"],
+    "siren_start": ["Siren"],
+    "siren_stop": ["Siren"],
     "ptz_up": ["PT", "PTZ"],
     "ptz_down": ["PT", "PTZ"],
     "ptz_left": ["PT", "PTZ"],
@@ -331,6 +353,15 @@ BUTTON_TYPE_REF = {
             ],
         },
     ],
+    "siren_start": [
+        {
+            "ref": IOT_SIREN_START_REF,
+            "input_ref": IOT_SIREN_START_INPUT_REF,
+        },
+    ],
+    "siren_stop": [
+        {"ref": IOT_SIREN_STOP_REF},
+    ],
     "ptz_up": [
         {"ref": "22100"},
         {"ref": "88700"},
@@ -371,6 +402,7 @@ BUTTON_TYPE_REF = {
 #  Required capacity for various select types
 SELECT_TYPE_ABILITY = {
     "night_vision_mode": ["NVM"],
+    "collection_point": ["CollectionPoint"],
 }
 SELECT_TYPE_REF = {
     "night_vision_mode": [
@@ -404,6 +436,16 @@ SELECT_TYPE_REF = {
             "value_type": "int",
         }
     ],
+    "collection_point": [
+        {
+            "ref": IOT_GET_COLLECTION_REF,
+            "turn_ref": IOT_TURN_COLLECTION_REF,
+            "turn_input_ref": IOT_TURN_COLLECTION_NAME_REF,
+            "ref_type": "services",
+            "default": PARAM_COLLECTION_POINT_PROMPT,
+            "options": [PARAM_COLLECTION_POINT_PROMPT],
+        }
+    ],
 }
 #  Required capacity for various sensor types
 SENSOR_TYPE_ABILITY = {

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

@@ -10,6 +10,7 @@ from .const import (
     API_ENDPOINT_CONTROL_DEVICE_PTZ,
     API_ENDPOINT_DEVICE_SD_CARD_STATUS,
     API_ENDPOINT_DEVICE_STORAGE,
+    API_ENDPOINT_GET_COLLECTION,
     API_ENDPOINT_GET_DEVICE_ALARM_PARAM,
     API_ENDPOINT_GET_DEVICE_LIVE_INFO,
     API_ENDPOINT_GET_DEVICE_NIGHT_VISION_MODE,
@@ -27,6 +28,9 @@ from .const import (
     API_ENDPOINT_SET_DEVICE_SNAP,
     API_ENDPOINT_SET_DEVICE_STATUS,
     API_ENDPOINT_SET_IOT_DEVICE_PROPERTIES,
+    API_ENDPOINT_SIREN_START,
+    API_ENDPOINT_SIREN_STOP,
+    API_ENDPOINT_TURN_COLLECTION,
     API_ENDPOINT_WAKE_UP_DEVICE,
     NIGHT_VISION_MODE_MAP,
     PARAM_ABILITY_REFS,
@@ -39,6 +43,7 @@ from .const import (
     PARAM_CHANNEL_NUM,
     PARAM_CHANNEL_STATUS,
     PARAM_CHANNELS,
+    PARAM_COLLECTION_NAME,
     PARAM_CONTENT,
     PARAM_COUNT,
     PARAM_DEVICE_ABILITY,
@@ -206,6 +211,10 @@ class ImouDevice:
     def parent_device_id(self) -> str | None:
         return self._parent_device_id
 
+    @property
+    def channel_number(self) -> int:
+        return self._channel_number
+
     @property
     def is_ipc(self) -> bool:
         return (
@@ -641,6 +650,45 @@ class ImouDeviceManager:
             API_ENDPOINT_GET_IOT_DEVICE_DETAIL_INFO, params
         )
 
+    async def async_get_device_collection(
+        self, device_id: str, channel_id: str
+    ) -> dict[str, Any]:
+        params = {
+            PARAM_DEVICE_ID: device_id,
+            PARAM_CHANNEL_ID: channel_id,
+        }
+        return await self._imou_api_client.async_request_api(
+            API_ENDPOINT_GET_COLLECTION, params
+        )
+
+    async def async_turn_device_collection(
+        self, device_id: str, channel_id: str, name: str
+    ) -> None:
+        params = {
+            PARAM_DEVICE_ID: device_id,
+            PARAM_CHANNEL_ID: channel_id,
+            PARAM_COLLECTION_NAME: name,
+        }
+        await self._imou_api_client.async_request_api(
+            API_ENDPOINT_TURN_COLLECTION, params
+        )
+
+    async def async_siren_start(
+        self, device_id: str, channels: list[int] | None = None
+    ) -> None:
+        params: dict[str, Any] = {PARAM_DEVICE_ID: device_id}
+        if channels is not None:
+            params[PARAM_CHANNELS] = channels
+        await self._imou_api_client.async_request_api(API_ENDPOINT_SIREN_START, params)
+
+    async def async_siren_stop(
+        self, device_id: str, channels: list[int] | None = None
+    ) -> None:
+        params: dict[str, Any] = {PARAM_DEVICE_ID: device_id}
+        if channels is not None:
+            params[PARAM_CHANNELS] = channels
+        await self._imou_api_client.async_request_api(API_ENDPOINT_SIREN_STOP, params)
+
     async def _async_update_device_ability_refs(self, imou_device: ImouDevice) -> None:
         device_id = imou_device.device_id
         if imou_device.parent_product_id is not None:

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

@@ -6,6 +6,11 @@ from typing import Any
 import aiohttp
 from simpleeval import SimpleEval
 
+from .collection_point import (
+    build_collection_point_options,
+    parse_iot_collection_names,
+    parse_paas_collection_names,
+)
 from .const import (
     BINARY_SENSOR_TYPE_ABILITY,
     BINARY_SENSOR_TYPE_REF,
@@ -21,6 +26,8 @@ from .const import (
     PARAM_BATTERY,
     PARAM_CHANNEL_ID,
     PARAM_CHANNELS,
+    PARAM_COLLECTION_POINT,
+    PARAM_COLLECTION_POINT_PROMPT,
     PARAM_CONTENT,
     PARAM_CURRENT_OPTION,
     PARAM_DEFAULT,
@@ -32,6 +39,7 @@ from .const import (
     PARAM_HD,
     PARAM_HLS,
     PARAM_HUMIDITY_CURRENT,
+    PARAM_INPUT_REF,
     PARAM_LITELEC,
     PARAM_MODE,
     PARAM_MODES,
@@ -47,6 +55,8 @@ from .const import (
     PARAM_REF_TYPE,
     PARAM_RESTART_DEVICE,
     PARAM_SERVICES,
+    PARAM_SIREN_START,
+    PARAM_SIREN_STOP,
     PARAM_STATE,
     PARAM_STATUS,
     PARAM_STORAGE_USED,
@@ -54,6 +64,8 @@ from .const import (
     PARAM_STREAMS,
     PARAM_TEMPERATURE_CURRENT,
     PARAM_TOTAL_BYTES,
+    PARAM_TURN_INPUT_REF,
+    PARAM_TURN_REF,
     PARAM_URL,
     PARAM_USED_BYTES,
     PARAM_VALUE_TYPE,
@@ -68,6 +80,7 @@ from .const import (
 from .device import ImouDevice, ImouDeviceManager
 from .exceptions import RequestFailedException
 from .sensor import apply_sensor_state
+from .siren import build_siren_start_iot_content
 
 _LOGGER: logging.Logger = logging.getLogger(__package__)
 
@@ -155,6 +168,7 @@ class ImouHaDevice:
         self._texts = {}
         self._channel_id = None
         self._channel_name = None
+        self._is_ipc = False
         self._product_id = None
         self._parent_product_id = None
         self._parent_device_id = None
@@ -171,6 +185,10 @@ class ImouHaDevice:
     def channel_name(self):
         return self._channel_name
 
+    @property
+    def is_ipc(self) -> bool:
+        return self._is_ipc
+
     @property
     def manufacturer(self):
         return self._manufacturer
@@ -245,6 +263,9 @@ class ImouHaDevice:
     def set_channel_name(self, channel_name):
         self._channel_name = channel_name
 
+    def set_is_ipc(self, is_ipc: bool) -> None:
+        self._is_ipc = is_ipc
+
 
 class ImouHaDeviceManager:
     def __init__(self, device_manager: ImouDeviceManager):
@@ -454,13 +475,79 @@ class ImouHaDeviceManager:
     async def _async_update_device_select_status(self, device: ImouHaDevice):
         """UPDATE SELECT STATUS"""
         for select_type, value in device.selects.items():
-            if PARAM_REF in value:
+            if select_type == PARAM_COLLECTION_POINT:
+                await self._async_update_device_collection_points(device)
+            elif PARAM_REF in value:
                 continue
             else:
                 await self._async_update_device_select_status_by_type(
                     device, select_type
                 )
 
+    async def _async_update_device_collection_points(self, device: ImouHaDevice):
+        """Refresh collection point preset names."""
+        if device.channel_id is None:
+            return
+        try:
+            names: list[str]
+            select_state = device.selects[PARAM_COLLECTION_POINT]
+            if select_state.get(PARAM_TURN_REF):
+                output = await self._get_state_from_properties_or_services(
+                    device,
+                    self._resolve_device_id(device),
+                    select_state,
+                    kind="select",
+                    key=PARAM_COLLECTION_POINT,
+                )
+                names = parse_iot_collection_names(output) if output is not None else []
+            else:
+                data = await self.delegate.async_get_device_collection(
+                    device.device_id, str(device.channel_id)
+                )
+                names = parse_paas_collection_names(data)
+        except Exception as err:
+            _LOGGER.warning(
+                "Failed to fetch collection points for %s: %s",
+                device.device_name,
+                err,
+            )
+            return
+
+        device.selects[PARAM_COLLECTION_POINT][PARAM_OPTIONS] = (
+            build_collection_point_options(names)
+        )
+        device.selects[PARAM_COLLECTION_POINT][PARAM_CURRENT_OPTION] = (
+            PARAM_COLLECTION_POINT_PROMPT
+        )
+
+    async def _async_select_collection_point_option(
+        self, device: ImouHaDevice, option: str
+    ) -> None:
+        if option == PARAM_COLLECTION_POINT_PROMPT:
+            return
+        if device.channel_id is None:
+            raise RequestFailedException("collection_point requires channel")
+
+        select_state = device.selects[PARAM_COLLECTION_POINT]
+        turn_ref = select_state.get(PARAM_TURN_REF)
+        if turn_ref:
+            if device.product_id is None:
+                raise RequestFailedException("collection_point iot requires product_id")
+            input_ref = select_state.get(PARAM_TURN_INPUT_REF)
+            if not input_ref:
+                raise RequestFailedException("collection_point missing turn input ref")
+            await self.delegate.async_iot_device_control(
+                self._resolve_device_id(device),
+                device.product_id,
+                turn_ref,
+                {input_ref: option},
+            )
+        else:
+            await self.delegate.async_turn_device_collection(
+                device.device_id, str(device.channel_id), option
+            )
+        select_state[PARAM_CURRENT_OPTION] = PARAM_COLLECTION_POINT_PROMPT
+
     async def _async_update_device_sensor_status(self, device: ImouHaDevice):
         """UPDATE SENSOR STATUS"""
         for sensor_type, value in device.sensors.items():
@@ -651,6 +738,7 @@ class ImouHaDeviceManager:
             imou_ha_device.set_parent_product_id(device.parent_product_id)
         if device.parent_device_id is not None:
             imou_ha_device.set_parent_device_id(device.parent_device_id)
+        imou_ha_device.set_is_ipc(device.is_ipc)
         return imou_ha_device
 
     async def async_press_button(
@@ -665,10 +753,37 @@ class ImouHaDeviceManager:
                 BUTTON_TYPE_PARAM_VALUE[button_type],
                 duration,
             )
+        elif button_type in (PARAM_SIREN_START, PARAM_SIREN_STOP):
+            await self._async_press_siren_button(device, button_type)
         elif device.buttons[button_type].get(PARAM_REF):
             ref_id = device.buttons[button_type].get(PARAM_REF)
             await self._async_press_button_by_ref(device, ref_id)
 
+    async def _async_press_siren_button(
+        self, device: ImouHaDevice, button_type: str
+    ) -> None:
+        button_state = device.buttons[button_type]
+        ref = button_state.get(PARAM_REF)
+        if ref:
+            content: dict[str, str] = {}
+            if button_type == PARAM_SIREN_START:
+                input_ref = button_state.get(PARAM_INPUT_REF)
+                if not input_ref:
+                    raise RequestFailedException("siren_start missing input ref")
+                content = build_siren_start_iot_content(input_ref)
+            await self._async_press_button_by_ref(device, ref, content)
+            return
+        if device.is_ipc:
+            channels = None
+        else:
+            if device.channel_id is None:
+                raise RequestFailedException(f"{button_type} requires channel")
+            channels = [int(device.channel_id)]
+        if button_type == PARAM_SIREN_START:
+            await self.delegate.async_siren_start(device.device_id, channels)
+        elif button_type == PARAM_SIREN_STOP:
+            await self.delegate.async_siren_stop(device.device_id, channels)
+
     async def async_set_text_value(
         self, device: ImouHaDevice, text_type: str, text_value: str
     ):
@@ -736,6 +851,7 @@ class ImouHaDeviceManager:
             # Request all failed, consider this operation a failure
             if all(isinstance(result_item, Exception) for result_item in result):
                 raise result[0]
+        device.switches[switch_type][PARAM_STATE] = enable
 
     async def async_select_option(
         self,
@@ -743,17 +859,27 @@ class ImouHaDeviceManager:
         select_type: str,
         option: str,
     ):
+        if select_type == PARAM_COLLECTION_POINT:
+            await self._async_select_collection_point_option(device, option)
+            return
         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
             # 兼容下音量15400值为-1的情况
             if ref_id == "15400" and option == "99":
-                option = "-1"
-            await self._async_select_option_by_ref(device, option, ref_id, value_type)
+                write_option = "-1"
+            await self._async_select_option_by_ref(
+                device, write_option, ref_id, value_type
+            )
+            device.selects[select_type][PARAM_CURRENT_OPTION] = option
         elif select_type == PARAM_NIGHT_VISION_MODE:
             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()
+            )
 
     async def _async_get_device_switch_status_by_ability(
         self, device: ImouHaDevice, ability_type: str
@@ -886,10 +1012,16 @@ class ImouHaDeviceManager:
                     select_type,
                     imou_ha_device.selects,
                 ):
-                    imou_ha_device.selects[select_type] = {
-                        PARAM_CURRENT_OPTION: "",
-                        PARAM_OPTIONS: [],
-                    }
+                    if select_type == PARAM_COLLECTION_POINT:
+                        imou_ha_device.selects[select_type] = {
+                            PARAM_CURRENT_OPTION: PARAM_COLLECTION_POINT_PROMPT,
+                            PARAM_OPTIONS: [PARAM_COLLECTION_POINT_PROMPT],
+                        }
+                    else:
+                        imou_ha_device.selects[select_type] = {
+                            PARAM_CURRENT_OPTION: "",
+                            PARAM_OPTIONS: [],
+                        }
 
     @staticmethod
     def configure_button_by_ability(
@@ -1083,9 +1215,10 @@ class ImouHaDeviceManager:
                     imou_ha_device.product_id,
                     ref.get(PARAM_EXCEPTS, []),
                 ):
-                    imou_ha_device.buttons[button_type] = {
-                        PARAM_REF: ref[PARAM_REF],
-                    }
+                    button_entry = {PARAM_REF: ref[PARAM_REF]}
+                    if ref.get(PARAM_INPUT_REF):
+                        button_entry[PARAM_INPUT_REF] = ref[PARAM_INPUT_REF]
+                    imou_ha_device.buttons[button_type] = button_entry
                     break
 
     @staticmethod
@@ -1108,12 +1241,21 @@ class ImouHaDeviceManager:
                     imou_ha_device.product_id,
                     ref.get(PARAM_EXCEPTS, []),
                 ):
-                    imou_ha_device.selects[select_type] = {
+                    select_entry = {
                         PARAM_REF: ref[PARAM_REF],
                         PARAM_OPTIONS: ref[PARAM_OPTIONS],
                         PARAM_CURRENT_OPTION: ref[PARAM_DEFAULT],
                         PARAM_VALUE_TYPE: ref.get(PARAM_VALUE_TYPE, "str"),
                     }
+                    if ref.get(PARAM_TURN_REF):
+                        select_entry[PARAM_TURN_REF] = ref[PARAM_TURN_REF]
+                        select_entry[PARAM_TURN_INPUT_REF] = ref.get(
+                            PARAM_TURN_INPUT_REF
+                        )
+                        select_entry[PARAM_REF_TYPE] = ref.get(
+                            PARAM_REF_TYPE, PARAM_PROPERTIES
+                        )
+                    imou_ha_device.selects[select_type] = select_entry
                     break
 
     @staticmethod
@@ -1285,18 +1427,14 @@ class ImouHaDeviceManager:
             state = data
         return state
 
-    async def _async_press_button_by_ref(self, device: ImouHaDevice, ref: str):
-        device_id = device.device_id
-        if device.parent_product_id is not None:
-            device_id = (
-                device_id
-                + "_"
-                + device.parent_device_id
-                + "_"
-                + device.parent_product_id
-            )
+    async def _async_press_button_by_ref(
+        self, device: ImouHaDevice, ref: str, content: dict | None = None
+    ):
+        if content is None:
+            content = {}
+        device_id = self._resolve_device_id(device)
         await self.delegate.async_iot_device_control(
-            device_id, device.product_id, ref, {}
+            device_id, device.product_id, ref, content
         )
 
     async def _async_select_option_by_ref(
@@ -1345,8 +1483,7 @@ class ImouHaDeviceManager:
             await self.delegate.async_set_iot_device_properties(
                 device.device_id, None, device.product_id, {ref: 1 if enable else 0}
             )
-        await asyncio.sleep(3)
-        await self._async_update_device_switch_status_by_ref(device, switch_type, ref)
+        device.switches[switch_type][PARAM_STATE] = enable
 
     @staticmethod
     def configure_binary_sensor_by_ability(

pyimouapi-1.3.3/pyimouapi/siren.py

@@ -0,0 +1,15 @@
+"""Siren button helpers."""
+
+from __future__ import annotations
+
+from datetime import datetime
+
+
+def client_local_time_iso() -> str:
+    """Return client local time for IoT SirenStart (yyyyMMdd'T'HHmmss)."""
+    return datetime.now().astimezone().strftime("%Y%m%dT%H%M%S")
+
+
+def build_siren_start_iot_content(input_ref: str) -> dict[str, str]:
+    """Build iotDeviceControl content for SirenStart."""
+    return {input_ref: client_local_time_iso()}

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: pyimouapi
-Version: 1.3.2
+Version: 1.3.3
 Summary: A package for imou open api
 Home-page: https://github.com/Imou-OpenPlatform/Py-Imou-Open-Api
 Author: Imou-OpenPlatform
@@ -30,8 +30,9 @@ Async Python client for the **Imou Open Platform** cloud APIs. Built on **aiohtt
 | Module | Role |
 |--------|------|
 | `pyimouapi.openapi` | `ImouOpenApiClient` — auth, signing, token lifecycle, HTTP calls |
-| `pyimouapi.device` | `ImouDeviceManager`, `ImouDevice`, `ImouChannel` — listing, PTZ, alarms, storage, and related endpoints |
-| `pyimouapi.ha_device` | `ImouHaDeviceManager`, `ImouHaDevice`, … — aggregated “device model” helpers for automation stacks |
+| `pyimouapi.device` | `ImouDeviceManager`, `ImouDevice`, `ImouChannel` — listing, PTZ, alarms, storage, collection points (`getCollection` / `turnCollection`), and related endpoints |
+| `pyimouapi.collection_point` | Parsing helpers for PaaS / IoT collection point (preset) name lists |
+| `pyimouapi.ha_device` | `ImouHaDeviceManager`, `ImouHaDevice`, … — aggregated “device model” helpers for automation stacks (including `select.collection_point` when the device exposes `CollectionPoint` or IoT refs `21500`/`22000`) |
 | `pyimouapi.exceptions` | `ImouException` and typed errors (connect, request, invalid credentials, …) |
 
 The top-level `pyimouapi` package re-exports common symbols. Import submodules directly when needed, for example `from pyimouapi.ha_device import ImouHaDeviceManager`.