pyimouapi 1.2.4__tar.gz → 1.2.5__tar.gz

{pyimouapi-1.2.4 → pyimouapi-1.2.5}/PKG-INFO

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

{pyimouapi-1.2.4 → pyimouapi-1.2.5}/pyimouapi/__init__.py

@@ -1,3 +1,5 @@
+__version__ = "1.2.5"
+
 from .device import ImouDeviceManager, ImouDevice, ImouChannel
 from .exceptions import (
     ConnectFailedException,

{pyimouapi-1.2.4 → pyimouapi-1.2.5}/pyimouapi/device.py

@@ -1,3 +1,7 @@
+from __future__ import annotations
+
+from typing import Any
+
 from .const import (
     API_ENDPOINT_LIST_DEVICE_DETAILS,
     PARAM_PAGE_SIZE,
@@ -137,7 +141,7 @@ class ImouDevice:
         return self._device_status
 
     @property
-    def channels(self) -> []:
+    def channels(self) -> list[ImouChannel]:
         return self._channels
 
     @property
@@ -157,15 +161,15 @@ class ImouDevice:
         return self._device_version
 
     @property
-    def product_id(self) -> str:
+    def product_id(self) -> str | None:
         return self._product_id
 
     @property
-    def parent_product_id(self) -> str:
+    def parent_product_id(self) -> str | None:
         return self._parent_product_id
 
     @property
-    def parent_device_id(self) -> str:
+    def parent_device_id(self) -> str | None:
         return self._parent_device_id
 
     @property
@@ -185,7 +189,7 @@ class ImouDevice:
     def set_product_id(self, product_id: str) -> None:
         self._product_id = product_id
 
-    def set_channels(self, channels: []) -> None:
+    def set_channels(self, channels: list[ImouChannel]) -> None:
         self._channels = channels
 
     def set_channel_number(self, channel_number: int):
@@ -311,7 +315,7 @@ class ImouDeviceManager:
 
     async def async_get_device_status(
         self, device_id: str, channel_id: str, enable_type: str
-    ) -> dict[any, any]:
+    ) -> dict[str, Any]:
         """obtain device capability switch status"""
         params = {
             PARAM_DEVICE_ID: device_id,
@@ -322,7 +326,7 @@ class ImouDeviceManager:
             API_ENDPOINT_GET_DEVICE_STATUS, params
         )
 
-    async def async_get_device_online_status(self, device_id: str) -> dict[any, any]:
+    async def async_get_device_online_status(self, device_id: str) -> dict[str, Any]:
         """GET DEVICE ONLINE STATUS"""
         params = {
             PARAM_DEVICE_ID: device_id,
@@ -346,7 +350,7 @@ class ImouDeviceManager:
 
     async def async_get_device_night_vision_mode(
         self, device_id: str, channel_id: str
-    ) -> dict[any, any]:
+    ) -> dict[str, Any]:
         """obtain device night vision mode"""
         params = {
             PARAM_DEVICE_ID: device_id,
@@ -371,7 +375,7 @@ class ImouDeviceManager:
             API_ENDPOINT_SET_DEVICE_NIGHT_VISION_MODE, params
         )
 
-    async def async_get_device_storage(self, device_id: str) -> dict[any, any]:
+    async def async_get_device_storage(self, device_id: str) -> dict[str, Any]:
         """obtain device storage media capacity information"""
         params = {PARAM_DEVICE_ID: device_id}
         return await self._imou_api_client.async_request_api(
@@ -387,7 +391,7 @@ class ImouDeviceManager:
 
     async def async_get_stream_url(
         self, device_id: str, channel_id: str
-    ) -> dict[any, any]:
+    ) -> dict[str, Any]:
         """obtain the hls stream address of the device"""
         params = {PARAM_DEVICE_ID: device_id, PARAM_CHANNEL_ID: channel_id}
         return await self._imou_api_client.async_request_api(
@@ -396,7 +400,7 @@ class ImouDeviceManager:
 
     async def async_get_device_snap(
         self, device_id: str, channel_id: str
-    ) -> dict[any, any]:
+    ) -> 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_SET_DEVICE_SNAP, params
@@ -404,7 +408,7 @@ class ImouDeviceManager:
 
     async def async_create_stream_url(
         self, device_id: str, channel_id: str, stream_id: int = 0
-    ) -> dict[any, any]:
+    ) -> dict[str, Any]:
         """create device hls stream address"""
         params = {
             PARAM_DEVICE_ID: device_id,
@@ -425,8 +429,12 @@ class ImouDeviceManager:
         )
 
     async def async_get_iot_device_properties(
-        self, device_id: str, channel_id: str | None, product_id: str, properties: []
-    ) -> dict[any, any]:
+        self,
+        device_id: str,
+        channel_id: str | None,
+        product_id: str,
+        properties: list[Any],
+    ) -> dict[str, Any]:
         params = {
             PARAM_DEVICE_LIST: [
                 {
@@ -462,15 +470,15 @@ class ImouDeviceManager:
             API_ENDPOINT_SET_IOT_DEVICE_PROPERTIES, params
         )
 
-    async def async_get_device_sd_card_status(self, device_id: str) -> dict[any, any]:
+    async def async_get_device_sd_card_status(self, device_id: str) -> dict[str, Any]:
         params = {PARAM_DEVICE_ID: device_id}
         return await self._imou_api_client.async_request_api(
             API_ENDPOINT_DEVICE_SD_CARD_STATUS, params
         )
 
     async def async_iot_device_control(
-        self, device_id: str, product_id: str, ref: str, content: dict
-    ) -> dict[str, any]:
+        self, device_id: str, product_id: str, ref: str, content: dict[str, Any]
+    ) -> dict[str, Any]:
         params = {
             PARAM_DEVICE_ID: device_id,
             PARAM_PRODUCT_ID: product_id,
@@ -481,7 +489,7 @@ class ImouDeviceManager:
             API_ENDPOINT_IOT_DEVICE_CONTROL, params
         )
 
-    async def async_get_device_power_info(self, device_id: str) -> dict[any, any]:
+    async def async_get_device_power_info(self, device_id: str) -> dict[str, Any]:
         params = {
             PARAM_DEVICE_ID: device_id,
         }
@@ -498,9 +506,7 @@ class ImouDeviceManager:
             API_ENDPOINT_WAKE_UP_DEVICE, params
         )
 
-
-
-    async def async_get_product_model(self, product_id: str) -> dict[any, any]:
+    async def async_get_product_model(self, product_id: str) -> dict[str, Any]:
         params = {
             PARAM_PRODUCT_ID: product_id,
         }
@@ -510,7 +516,7 @@ class ImouDeviceManager:
 
     async def async_get_iot_device_detail_info(
         self, device_id: str, product_id: str
-    ) -> dict[any, any]:
+    ) -> dict[str, Any]:
         params = {
             PARAM_DEVICE_ID: device_id,
             PARAM_PRODUCT_ID: product_id,

{pyimouapi-1.2.4 → pyimouapi-1.2.5}/pyimouapi/exceptions.py

@@ -14,8 +14,10 @@ class ImouException(Exception):
 
     def traceback(self) -> str:
         """Return the traceback as a string."""
-        etype, value, trace = sys.exc_info()
-        return "".join(traceback.format_exception(etype, value, trace, None))
+        exc_info = sys.exc_info()
+        if exc_info[0] is None:
+            return ""
+        return "".join(traceback.format_exception(*exc_info))
 
     def get_title(self) -> str:
         """Return the title of the exception which will be then translated."""

{pyimouapi-1.2.4 → pyimouapi-1.2.5}/pyimouapi/ha_device.py

@@ -323,10 +323,8 @@ class ImouHaDeviceManager(object):
                         return await self._async_get_device_exist_stream(
                             device, live_resolution, live_protocol
                         )
-                    else:
-                        raise exception
-            else:
-                raise exception
+                    raise ex
+            raise exception
 
     async def _async_get_device_exist_stream(
             self, device: ImouHaDevice, resolution: str, protocol: str
@@ -352,8 +350,9 @@ class ImouHaDeviceManager(object):
             _LOGGER.debug(f"wait {wait_seconds} seconds to download a picture")
             await asyncio.sleep(wait_seconds)
         try:
-            async with aiohttp.ClientSession() as session:
-                response = await session.request("GET", data[PARAM_URL])
+            timeout = aiohttp.ClientTimeout(total=120)
+            async with aiohttp.ClientSession(timeout=timeout) as session:
+                response = await session.get(data[PARAM_URL])
                 if response.status != 200:
                     raise RequestFailedException(
                         f"request failed,status code {response.status}"

{pyimouapi-1.2.4 → pyimouapi-1.2.5}/pyimouapi/openapi.py

@@ -5,8 +5,10 @@ import logging
 import secrets
 import time
 import uuid
+from typing import Any
 
 import aiohttp
+from urllib.parse import urlparse
 
 from .const import (
     API_ENDPOINT_ACCESS_TOKEN,
@@ -40,28 +42,49 @@ _LOGGER: logging.Logger = logging.getLogger(__package__)
 
 
 class ImouOpenApiClient:
+    """Async client for Imou Open Platform HTTP API."""
+
     def __init__(self, app_id: str, app_secret: str, api_url: str) -> None:
         self._app_id = app_id
         self._app_secret = app_secret
         self._api_url = api_url
-        # token
-        self._access_token = None
+        self._access_token: str | None = None
+        self._session: aiohttp.ClientSession | None = None
+
+    async def _async_get_session(self) -> aiohttp.ClientSession:
+        if self._session is None or self._session.closed:
+            self._session = aiohttp.ClientSession(
+                headers={"Client-Type": "HomeAssistant"},
+            )
+        return self._session
+
+    async def async_close(self) -> None:
+        """Close the HTTP session (call when done with the client)."""
+        if self._session is not None and not self._session.closed:
+            await self._session.close()
+            self._session = None
 
     async def async_get_token(self) -> None:
-        """get accessToken"""
+        """Fetch and store accessToken."""
         response = await self.async_request_api(API_ENDPOINT_ACCESS_TOKEN, {})
         self._access_token = response[PARAM_ACCESS_TOKEN]
         if PARAM_CURRENT_DOMAIN in response:
-            self._api_url = response[PARAM_CURRENT_DOMAIN].split("://")[1]
+            raw = response[PARAM_CURRENT_DOMAIN]
+            if "://" not in raw:
+                raw = f"https://{raw}"
+            parsed = urlparse(raw)
+            if parsed.netloc:
+                self._api_url = parsed.netloc
 
     async def async_request_api(
-        self, endpoint: str, params: dict[any, any] = None
-    ) -> dict[any, any]:
-        # if accessToken is None , get first
+        self, endpoint: str, params: dict[str, Any] | None = None
+    ) -> dict[str, Any]:
+        """POST to an API endpoint; returns the result data object."""
+        payload = dict(params) if params else {}
         if self._access_token is None and endpoint != API_ENDPOINT_ACCESS_TOKEN:
             await self.async_get_token()
         if endpoint != API_ENDPOINT_ACCESS_TOKEN:
-            params[PARAM_TOKEN] = self._access_token
+            payload[PARAM_TOKEN] = self._access_token
         timestamp = round(time.time())
         nonce = secrets.token_urlsafe()
         sign = hashlib.md5(
@@ -70,7 +93,7 @@ class ImouOpenApiClient:
             )
         ).hexdigest()
         request_id = str(uuid.uuid4())
-        headers = {"Content-Type": "application/json", "Client-Type": "HomeAssistant"}
+        headers = {"Content-Type": "application/json"}
         body = {
             PARAM_SYSTEM: {
                 PARAM_VER: "1.0",
@@ -79,20 +102,16 @@ class ImouOpenApiClient:
                 PARAM_TIME: timestamp,
                 PARAM_NONCE: nonce,
             },
-            PARAM_PARAMS: params,
+            PARAM_PARAMS: payload,
             PARAM_ID: request_id,
         }
         url = f"https://{self._api_url}{endpoint}"
+        session = await self._async_get_session()
         try:
-            async with aiohttp.ClientSession() as session:
-                async with asyncio.timeout(30):
-                    response = await session.request(
-                        "POST", url, json=body, headers=headers
-                    )
-                    response_body = json.loads(await response.text())
-                    _LOGGER.debug(
-                        f"url: {url} request body: {body} response: {response_body}"
-                    )
+            async with asyncio.timeout(30):
+                response = await session.request("POST", url, json=body, headers=headers)
+                response_body = json.loads(await response.text())
+                _LOGGER.debug("url: %s request body: %s response: %s", url, body, response_body)
         except Exception as exception:
             raise ConnectFailedException(f"connect failed,{exception}") from exception
         if response.status != 200:
@@ -117,5 +136,5 @@ class ImouOpenApiClient:
         return response_data
 
     @property
-    def access_token(self):
+    def access_token(self) -> str | None:
         return self._access_token

{pyimouapi-1.2.4 → pyimouapi-1.2.5}/pyimouapi.egg-info/PKG-INFO

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

{pyimouapi-1.2.4 → pyimouapi-1.2.5}/pyimouapi.egg-info/SOURCES.txt

@@ -1,5 +1,6 @@
 LICENSE
 README.md
+pyproject.toml
 setup.py
 pyimouapi/__init__.py
 pyimouapi/const.py

pyimouapi-1.2.5/pyproject.toml

@@ -0,0 +1,3 @@
+[build-system]
+requires = ["setuptools>=61", "wheel"]
+build-backend = "setuptools.build_meta"

{pyimouapi-1.2.4 → pyimouapi-1.2.5}/setup.py

@@ -2,7 +2,7 @@ from setuptools import setup, find_packages
 
 setup(
     name="pyimouapi",
-    version="1.2.4",
+    version="1.2.5",
     packages=find_packages(),
     python_requires=">=3.11",
     install_requires=[