aioamazondevices 6.5.0__tar.gz → 6.5.2__tar.gz

{aioamazondevices-6.5.0 → aioamazondevices-6.5.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: aioamazondevices
-Version: 6.5.0
+Version: 6.5.2
 Summary: Python library to control Amazon devices
 License-Expression: Apache-2.0
 License-File: LICENSE

{aioamazondevices-6.5.0 → aioamazondevices-6.5.2}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "aioamazondevices"
-version = "6.5.0"
+version = "6.5.2"
 requires-python = ">=3.12"
 description = "Python library to control Amazon devices"
 authors = [

{aioamazondevices-6.5.0 → aioamazondevices-6.5.2}/src/aioamazondevices/__init__.py

@@ -1,6 +1,6 @@
 """aioamazondevices library."""
 
-__version__ = "6.5.0"
+__version__ = "6.5.2"
 
 
 from .api import AmazonDevice, AmazonEchoApi

{aioamazondevices-6.5.0 → aioamazondevices-6.5.2}/src/aioamazondevices/api.py

@@ -40,6 +40,7 @@ from .const import (
     AMAZON_CLIENT_OS,
     AMAZON_DEVICE_SOFTWARE_VERSION,
     AMAZON_DEVICE_TYPE,
+    ARRAY_WRAPPER,
     BIN_EXTENSION,
     COUNTRY_GROUPS,
     CSRF_COOKIE,
@@ -61,6 +62,7 @@ from .const import (
     REQUEST_AGENT,
     SAVE_PATH,
     SENSORS,
+    SPEAKER_GROUP_FAMILY,
     URI_DEVICES,
     URI_DND,
     URI_NEXUS_GRAPHQL,
@@ -606,20 +608,19 @@ class AmazonEchoApi:
         _LOGGER.info("Register device: %s", scrub_fields(login_data))
         return login_data
 
-    async def _get_sensors_state(
-        self, endpoint_id_list: list[str]
-    ) -> dict[str, Any] | list[dict[str, Any]]:
-        """Get sensor State."""
+    async def _get_sensors_states(self) -> dict[str, dict[str, AmazonDeviceSensor]]:
+        """Retrieve devices sensors states."""
+        devices_sensors: dict[str, dict[str, AmazonDeviceSensor]] = {}
+
+        endpoint_ids = list(self._endpoints.keys())
         payload = [
             {
                 "operationName": "getEndpointState",
                 "variables": {
-                    "endpointId": endpoint_id,
-                    "latencyTolerance": "LOW",
+                    "endpointIds": endpoint_ids,
                 },
                 "query": QUERY_SENSOR_STATE,
             }
-            for endpoint_id in endpoint_id_list
         ]
 
         _, raw_resp = await self._session_request(
@@ -629,47 +630,29 @@ class AmazonEchoApi:
             json_data=True,
         )
 
-        return await self._response_to_json(raw_resp)
+        sensors_state = await self._response_to_json(raw_resp)
+        _LOGGER.debug("Sensor data - %s", sensors_state)
 
-    async def _get_sensors_states(self) -> dict[str, dict[str, AmazonDeviceSensor]]:
-        """Retrieve devices sensors states."""
-        devices_sensors: dict[str, dict[str, AmazonDeviceSensor]] = {}
+        if await self._format_human_error(sensors_state):
+            # Explicit error in returned data
+            return {}
 
-        # batch endpoints into groups of 3 to reduce number of requests
-        endpoint_ids = list(self._endpoints.keys())
-        batches = [endpoint_ids[i : i + 3] for i in range(0, len(endpoint_ids), 3)]
-        for endpoint_id_batch in batches:
-            sensors_state = await self._get_sensors_state(endpoint_id_batch)
-            _LOGGER.debug("Sensor data - %s", sensors_state)
+        if (
+            not (arr := sensors_state.get(ARRAY_WRAPPER))
+            or not (data := arr[0].get("data"))
+            or not (endpoints_list := data.get("listEndpoints"))
+            or not (endpoints := endpoints_list.get("endpoints"))
+        ):
+            _LOGGER.error("Malformed sensor state data received: %s", sensors_state)
+            return {}
 
-            if not isinstance(sensors_state, list) and (
-                error := sensors_state.get("errors")
-            ):
-                if isinstance(error, list):
-                    error = error[0]
-                msg = error.get("message", "Unknown error")
-                path = error.get("path", "Unknown path")
-                _LOGGER.error(
-                    "Error retrieving devices state: %s for path %s", msg, path
-                )
-                return {}
+        for endpoint in endpoints:
+            serial_number = self._endpoints[endpoint.get("endpointId")]
 
-            for endpoint_data in sensors_state:
-                if (
-                    not isinstance(endpoint_data, dict)
-                    or not (data := endpoint_data.get("data"))
-                    or not (endpoint := data.get("endpoint"))
-                ):
-                    _LOGGER.error(
-                        "Malformed sensor state data received: %s", endpoint_data
-                    )
-                    return {}
-                serial_number = self._endpoints[endpoint.get("endpointId")]
-
-                if serial_number in self._final_devices:
-                    devices_sensors[serial_number] = self._get_device_sensor_state(
-                        endpoint, serial_number
-                    )
+            if serial_number in self._final_devices:
+                devices_sensors[serial_number] = self._get_device_sensor_state(
+                    endpoint, serial_number
+                )
 
         return devices_sensors
 
@@ -730,14 +713,16 @@ class AmazonEchoApi:
                     _LOGGER.debug(
                         "error in sensor %s - %s - %s", name, error_type, error_msg
                     )
-                device_sensors[name] = AmazonDeviceSensor(
-                    name,
-                    value,
-                    error,
-                    error_type,
-                    error_msg,
-                    scale,
-                )
+
+                if error_type != "NOT_FOUND":
+                    device_sensors[name] = AmazonDeviceSensor(
+                        name,
+                        value,
+                        error,
+                        error_type,
+                        error_msg,
+                        scale,
+                    )
 
         return device_sensors
 
@@ -758,7 +743,7 @@ class AmazonEchoApi:
         endpoint_data = await self._response_to_json(raw_resp)
 
         if not (data := endpoint_data.get("data")) or not data.get("listEndpoints"):
-            _LOGGER.error("Malformed endpoint data received: %s", endpoint_data)
+            await self._format_human_error(endpoint_data)
             return {}
 
         endpoints = data["listEndpoints"]
@@ -782,6 +767,10 @@ class AmazonEchoApi:
             if not data:
                 _LOGGER.warning("Empty JSON data received")
                 data = {}
+            if isinstance(data, list):
+                # if anonymous array is returned wrap it inside
+                # generated key to convert list to dict
+                data = {ARRAY_WRAPPER: data}
             return cast("dict[str, Any]", data)
         except ContentTypeError as exc:
             raise ValueError("Response not in JSON format") from exc
@@ -1153,7 +1142,9 @@ class AmazonEchoApi:
             else:
                 for device_sensor in device.sensors.values():
                     device_sensor.error = True
-            if device_dnd := dnd_sensors.get(device.serial_number):
+            if (
+                device_dnd := dnd_sensors.get(device.serial_number)
+            ) and device.device_family != SPEAKER_GROUP_FAMILY:
                 device.sensors["dnd"] = device_dnd
 
             # Update notifications
@@ -1222,11 +1213,20 @@ class AmazonEchoApi:
             if not device or (device.get("deviceType") in DEVICE_TO_IGNORE):
                 continue
 
+            account_name: str = device["accountName"]
+            capabilities: list[str] = device["capabilities"]
+            # Skip devices that cannot be used with voice features
+            if "MICROPHONE" not in capabilities:
+                _LOGGER.debug(
+                    "Skipping device without microphone capabilities: %s", account_name
+                )
+                continue
+
             serial_number: str = device["serialNumber"]
 
             final_devices_list[serial_number] = AmazonDevice(
-                account_name=device["accountName"],
-                capabilities=device["capabilities"],
+                account_name=account_name,
+                capabilities=capabilities,
                 device_family=device["deviceFamily"],
                 device_type=device["deviceType"],
                 device_owner_customer_id=device["deviceOwnerCustomerId"],
@@ -1576,3 +1576,18 @@ class AmazonEchoApi:
                 scale=None,
             )
         return dnd_status
+
+    async def _format_human_error(self, sensors_state: dict) -> bool:
+        """Format human readable error from malformed data."""
+        if sensors_state.get(ARRAY_WRAPPER):
+            error = sensors_state[ARRAY_WRAPPER][0].get("errors", [])
+        else:
+            error = sensors_state.get("errors", [])
+
+        if not error:
+            return False
+
+        msg = error[0].get("message", "Unknown error")
+        path = error[0].get("path", "Unknown path")
+        _LOGGER.error("Error retrieving devices state: %s for path %s", msg, path)
+        return True

{aioamazondevices-6.5.0 → aioamazondevices-6.5.2}/src/aioamazondevices/const.py

@@ -4,6 +4,8 @@ import logging
 
 _LOGGER = logging.getLogger(__package__)
 
+ARRAY_WRAPPER = "generatedArrayWrapper"
+
 HTTP_ERROR_199 = 199
 HTTP_ERROR_299 = 299
 

{aioamazondevices-6.5.0 → aioamazondevices-6.5.2}/src/aioamazondevices/query.py

@@ -41,44 +41,57 @@ query getDevicesBaseData {
 """
 
 QUERY_SENSOR_STATE = """
-query getEndpointState($endpointId: String!, $latencyTolerance: LatencyToleranceValue) {
-  endpoint(id: $endpointId) {
-    endpointId: id
-    features(latencyToleranceValue: $latencyTolerance) {
+fragment EndpointState on Endpoint {
+  endpointId: id
+  friendlyNameObject { value { text } }
+  features {
+    name
+    properties {
       name
-      instance
-      properties {
+      type
+      accuracy
+      error { type message }
+      __typename
+      ... on Illuminance {
+        illuminanceValue { value }
+        timeOfSample
+        timeOfLastChange
+      }
+      ... on Reachability {
+        reachabilityStatusValue
+        timeOfSample
+        timeOfLastChange
+      }
+      ... on DetectionState {
+        detectionStateValue
+        timeOfSample
+        timeOfLastChange
+      }
+      ... on TemperatureSensor {
         name
-        type
-        accuracy
-        error { type message }
-        __typename
-        ... on Illuminance {
-          illuminanceValue { value }
-          timeOfSample
-          timeOfLastChange
-        }
-        ... on Reachability {
-          reachabilityStatusValue
-          timeOfSample
-          timeOfLastChange
-        }
-        ... on DetectionState {
-          detectionStateValue
-          timeOfSample
-          timeOfLastChange
-        }
-        ... on TemperatureSensor {
-          name
-          value {
-            value
-            scale
-          }
-          timeOfSample
-          timeOfLastChange
+        value {
+          value
+          scale
         }
+        timeOfSample
+        timeOfLastChange
       }
     }
   }
 }
+
+
+query getEndpointState($endpointIds: [String]!) {
+  listEndpoints(
+    listEndpointsInput: {
+      latencyTolerance: LOW,
+      endpointIds: $endpointIds,
+      includeHouseholdDevices: true
+    }
+  ) {
+    endpoints {
+      ...EndpointState
+    }
+  }
+}
 """