aioamazondevices 6.2.8__py3-none-any.whl → 6.4.0__py3-none-any.whl

aioamazondevices/__init__.py

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

aioamazondevices/api.py

@@ -53,6 +53,7 @@ from .const import (
     SAVE_PATH,
     SENSORS,
     URI_DEVICES,
+    URI_DND,
     URI_NEXUS_GRAPHQL,
     URI_SIGNIN,
 )
@@ -63,7 +64,7 @@ from .exceptions import (
     CannotRetrieveData,
     WrongMethod,
 )
-from .query import QUERY_DEVICE_STATE
+from .query import QUERY_DEVICE_DATA, QUERY_SENSOR_STATE
 from .utils import obfuscate_email, scrub_fields
 
 
@@ -74,6 +75,8 @@ class AmazonDeviceSensor:
     name: str
     value: str | int | float
     error: bool
+    error_type: str | None
+    error_msg: str | None
     scale: str | None
 
 
@@ -141,7 +144,12 @@ class AmazonEchoApi:
         self._list_for_clusters: dict[str, str] = {}
 
         self._session = client_session
-        self._devices: dict[str, Any] = {}
+        self._final_devices: dict[str, AmazonDevice] = {}
+        self._endpoints: dict[str, str] = {}  # endpoint ID to serial number map
+
+        initial_time = datetime.now(UTC) - timedelta(days=2)  # force initial refresh
+        self._last_devices_refresh: datetime = initial_time
+        self._last_endpoint_refresh: datetime = initial_time
 
         _LOGGER.debug("Initialize library v%s", __version__)
 
@@ -337,7 +345,7 @@ class AmazonEchoApi:
         self,
         method: str,
         url: str,
-        input_data: dict[str, Any] | None = None,
+        input_data: dict[str, Any] | list[dict[str, Any]] | None = None,
         json_data: bool = False,
     ) -> tuple[BeautifulSoup, ClientResponse]:
         """Return request response context data."""
@@ -573,17 +581,21 @@ class AmazonEchoApi:
         _LOGGER.info("Register device: %s", scrub_fields(login_data))
         return login_data
 
-    async def _get_devices_state(
-        self,
-    ) -> dict[str, Any]:
-        """Get Device State."""
-        payload = {
-            "operationName": "getDevicesState",
-            "variables": {
-                "latencyTolerance": "LOW",
-            },
-            "query": QUERY_DEVICE_STATE,
-        }
+    async def _get_sensors_state(
+        self, endpoint_id_list: list[str]
+    ) -> dict[str, Any] | list[dict[str, Any]]:
+        """Get sensor State."""
+        payload = [
+            {
+                "operationName": "getEndpointState",
+                "variables": {
+                    "endpointId": endpoint_id,
+                    "latencyTolerance": "LOW",
+                },
+                "query": QUERY_SENSOR_STATE,
+            }
+            for endpoint_id in endpoint_id_list
+        ]
 
         _, raw_resp = await self._session_request(
             method=HTTPMethod.POST,
@@ -594,52 +606,52 @@ class AmazonEchoApi:
 
         return await self._response_to_json(raw_resp)
 
-    async def _get_sensors_states(
-        self,
-    ) -> tuple[dict[str, dict[str, Any]], dict[str, dict[str, AmazonDeviceSensor]]]:
+    async def _get_sensors_states(self) -> dict[str, dict[str, AmazonDeviceSensor]]:
         """Retrieve devices sensors states."""
-        devices_state = await self._get_devices_state()
         devices_sensors: dict[str, dict[str, AmazonDeviceSensor]] = {}
-        devices_endpoints: dict[str, dict[str, Any]] = {}
-
-        if error := devices_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 {}, {}
-
-        if not (data := devices_state.get("data")) or not data.get("listEndpoints"):
-            _LOGGER.error("Malformed devices state data received: %s", devices_state)
-            return {}, {}
 
-        endpoints = data["listEndpoints"]
-        for endpoint in endpoints.get("endpoints"):
-            serial_number = (
-                endpoint["serialNumber"]["value"]["text"]
-                if endpoint["serialNumber"]
-                else None
-            )
-            if serial_number in self._devices:
-                devices_sensors[serial_number] = self._get_device_sensor_state(
-                    endpoint, serial_number
+        # 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 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
                 )
-                devices_endpoints[serial_number] = endpoint
-
-        return devices_endpoints, devices_sensors
+                return {}
+
+            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
+                    )
+
+        return devices_sensors
 
     def _get_device_sensor_state(
         self, endpoint: dict[str, Any], serial_number: str
     ) -> dict[str, AmazonDeviceSensor]:
         device_sensors: dict[str, AmazonDeviceSensor] = {}
-        if endpoint_dnd := endpoint.get("settings", {}).get("doNotDisturb"):
-            device_sensors["dnd"] = AmazonDeviceSensor(
-                name="dnd",
-                value=endpoint_dnd.get("toggleValue"),
-                error=bool(endpoint_dnd.get("error")),
-                scale=None,
-            )
         for feature in endpoint.get("features", {}):
             if (sensor_template := SENSORS.get(feature["name"])) is None:
                 # Skip sensors that are not in the predefined list
@@ -654,7 +666,11 @@ class AmazonEchoApi:
 
                 value: str | int | float = "n/a"
                 scale: str | None = None
-                error = bool(feature_property.get("error"))
+
+                api_error = feature_property.get("error", {})
+                error = bool(api_error)
+                error_type = api_error.get("type")
+                error_msg = api_error.get("message")
                 if not error:
                     try:
                         value_raw = feature_property[sensor_template["key"]]
@@ -684,15 +700,56 @@ class AmazonEchoApi:
                             feature_property,
                             repr(exc),
                         )
+                if error:
+                    _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,
                 )
 
         return device_sensors
 
+    async def _get_devices_endpoint_data(self) -> dict[str, dict[str, Any]]:
+        """Get Devices endpoint data."""
+        payload = {
+            "operationName": "getDevicesBaseData",
+            "query": QUERY_DEVICE_DATA,
+        }
+
+        _, raw_resp = await self._session_request(
+            method=HTTPMethod.POST,
+            url=f"https://alexa.amazon.{self._domain}{URI_NEXUS_GRAPHQL}",
+            input_data=payload,
+            json_data=True,
+        )
+
+        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)
+            return {}
+
+        endpoints = data["listEndpoints"]
+        devices_endpoints: dict[str, dict[str, Any]] = {}
+        for endpoint in endpoints.get("endpoints"):
+            # save looking up sensor data on apps
+            if endpoint.get("alexaEnabledMetadata", {}).get("category") == "APP":
+                continue
+
+            if endpoint.get("serialNumber"):
+                serial_number = endpoint["serialNumber"]["value"]["text"]
+                devices_endpoints[serial_number] = endpoint
+                self._endpoints[endpoint["endpointId"]] = serial_number
+
+        self._last_endpoint_refresh = datetime.now(UTC)
+        return devices_endpoints
+
     async def _response_to_json(self, raw_resp: ClientResponse) -> dict[str, Any]:
         """Convert response to JSON, if possible."""
         try:
@@ -843,11 +900,77 @@ class AmazonEchoApi:
             self._country_specific_data(user_domain)
             await self._refresh_auth_cookies()
 
+    async def _get_account_owner_customer_id(self, data: dict[str, Any]) -> str | None:
+        """Get account owner customer ID."""
+        if data["deviceType"] != AMAZON_DEVICE_TYPE:
+            return None
+
+        account_owner_customer_id: str | None = None
+
+        this_device_serial = self._login_stored_data["device_info"][
+            "device_serial_number"
+        ]
+
+        for subdevice in data["appDeviceList"]:
+            if subdevice["serialNumber"] == this_device_serial:
+                account_owner_customer_id = data["deviceOwnerCustomerId"]
+                _LOGGER.debug(
+                    "Setting account owner: %s",
+                    account_owner_customer_id,
+                )
+                break
+
+        return account_owner_customer_id
+
     async def get_devices_data(
         self,
     ) -> dict[str, AmazonDevice]:
         """Get Amazon devices data."""
-        self._devices = {}
+        if not self._final_devices or (
+            datetime.now(UTC) - self._last_devices_refresh >= timedelta(days=1)
+        ):
+            # Request base device data
+            await self._get_base_devices()
+
+        if not self._endpoints or (
+            datetime.now(UTC) - self._last_endpoint_refresh >= timedelta(minutes=30)
+        ):
+            # Set device endpoint data
+            await self._set_device_endpoints_data()
+
+        await self._get_sensor_data()
+
+        return self._final_devices
+
+    async def _get_sensor_data(self) -> None:
+        devices_sensors = await self._get_sensors_states()
+        dnd_sensors = await self._get_dnd_status()
+        for device in self._final_devices.values():
+            # Update sensors
+            sensors = devices_sensors.get(device.serial_number, {})
+            if sensors:
+                device.sensors = sensors
+            else:
+                for device_sensor in device.sensors.values():
+                    device_sensor.error = True
+            if device_dnd := dnd_sensors.get(device.serial_number):
+                device.sensors["dnd"] = device_dnd
+
+    async def _set_device_endpoints_data(self) -> None:
+        devices_endpoints = await self._get_devices_endpoint_data()
+        for serial_number in self._final_devices:
+            device_endpoint = devices_endpoints.get(serial_number, {})
+            endpoint_device = self._final_devices[serial_number]
+            endpoint_device.entity_id = (
+                device_endpoint["legacyIdentifiers"]["chrsIdentifier"]["entityId"]
+                if device_endpoint
+                else None
+            )
+            endpoint_device.endpoint_id = (
+                device_endpoint["endpointId"] if device_endpoint else None
+            )
+
+    async def _get_base_devices(self) -> None:
         _, raw_resp = await self._session_request(
             method=HTTPMethod.GET,
             url=f"https://alexa.amazon.{self._domain}{URI_DEVICES}",
@@ -857,27 +980,28 @@ class AmazonEchoApi:
 
         _LOGGER.debug("JSON devices data: %s", scrub_fields(json_data))
 
-        this_device_serial = self._login_stored_data["device_info"][
-            "device_serial_number"
-        ]
         for data in json_data["devices"]:
             dev_serial = data.get("serialNumber")
-            self._devices[dev_serial] = data
-            if dev_serial == this_device_serial:
-                self._account_owner_customer_id = data["deviceOwnerCustomerId"]
+            if not dev_serial:
+                _LOGGER.warning(
+                    "Skipping device without serial number: %s", data["accountName"]
+                )
+                continue
+            if not self._account_owner_customer_id:
+                self._account_owner_customer_id = (
+                    await self._get_account_owner_customer_id(data)
+                )
 
-        devices_endpoints, devices_sensors = await self._get_sensors_states()
+        if not self._account_owner_customer_id:
+            raise CannotRetrieveData("Cannot find account owner customer ID")
 
         final_devices_list: dict[str, AmazonDevice] = {}
-        for device in self._devices.values():
+        for device in json_data["devices"]:
             # Remove stale, orphaned and virtual devices
             if not device or (device.get("deviceType") in DEVICE_TO_IGNORE):
                 continue
 
             serial_number: str = device["serialNumber"]
-            # Add sensors
-            sensors = devices_sensors.get(serial_number, {})
-            device_endpoint = devices_endpoints.get(serial_number, {})
 
             final_devices_list[serial_number] = AmazonDevice(
                 account_name=device["accountName"],
@@ -891,13 +1015,9 @@ class AmazonEchoApi:
                 online=device["online"],
                 serial_number=serial_number,
                 software_version=device["softwareVersion"],
-                entity_id=device_endpoint["legacyIdentifiers"]["chrsIdentifier"][
-                    "entityId"
-                ]
-                if device_endpoint
-                else None,
-                endpoint_id=device_endpoint["endpointId"] if device_endpoint else None,
-                sensors=sensors,
+                entity_id=None,
+                endpoint_id=None,
+                sensors={},
             )
 
         self._list_for_clusters.update(
@@ -907,7 +1027,8 @@ class AmazonEchoApi:
             }
         )
 
-        return final_devices_list
+        self._final_devices = final_devices_list
+        self._last_devices_refresh = datetime.now(UTC)
 
     async def auth_check_status(self) -> bool:
         """Check AUTH status."""
@@ -1212,3 +1333,24 @@ class AmazonEchoApi:
 
         _LOGGER.debug("Unexpected refresh data response")
         return False, {}
+
+    async def _get_dnd_status(self) -> dict[str, AmazonDeviceSensor]:
+        dnd_status: dict[str, AmazonDeviceSensor] = {}
+        _, raw_resp = await self._session_request(
+            method=HTTPMethod.GET,
+            url=f"https://alexa.amazon.{self._domain}{URI_DND}",
+        )
+
+        dnd_data = await self._response_to_json(raw_resp)
+        _LOGGER.debug("DND data: %s", dnd_data)
+
+        for dnd in dnd_data.get("doNotDisturbDeviceStatusList", {}):
+            dnd_status[dnd.get("deviceSerialNumber")] = AmazonDeviceSensor(
+                name="dnd",
+                value=dnd.get("enabled"),
+                error=False,
+                error_type=None,
+                error_msg=None,
+                scale=None,
+            )
+        return dnd_status

aioamazondevices/const.py

@@ -52,6 +52,7 @@ REFRESH_ACCESS_TOKEN = "access_token"  # noqa: S105
 REFRESH_AUTH_COOKIES = "auth_cookies"
 
 URI_DEVICES = "/api/devices-v2/device"
+URI_DND = "/api/dnd/device-status-list"
 URI_SIGNIN = "/ap/signin"
 URI_NEXUS_GRAPHQL = "/nexus/v1/graphql"
 
@@ -85,12 +86,6 @@ SENSORS: dict[str, dict[str, str | None]] = {
         "subkey": "value",
         "scale": None,
     },
-    "speaker": {
-        "name": "volume",
-        "key": "value",
-        "subkey": "volValue",
-        "scale": None,
-    },
 }
 DEVICE_TO_IGNORE: list[str] = [
     AMAZON_DEVICE_TYPE,  # Alexa App for iOS

aioamazondevices/query.py

@@ -1,8 +1,14 @@
 """GraphQL Queries."""
 
-QUERY_DEVICE_STATE = """
-query getDevicesState ($latencyTolerance: LatencyToleranceValue) {
-  listEndpoints(listEndpointsInput: { includeHouseholdDevices: true }) {
+QUERY_DEVICE_DATA = """
+query getDevicesBaseData {
+  listEndpoints(
+    listEndpointsInput: {
+        displayCategory: "ALEXA_VOICE_ENABLED"
+        includeHouseholdDevices: true
+    }
+  )
+  {
     endpoints {
       endpointId: id
       friendlyNameObject { value { text } }
@@ -12,18 +18,6 @@ query getDevicesState ($latencyTolerance: LatencyToleranceValue) {
       softwareVersion { value { text } }
       creationTime
       enablement
-      settings {
-        doNotDisturb {
-          id
-          endpointId
-          name
-          toggleValue
-          error {
-            type
-            message
-          }
-        }
-      }
       displayCategories {
         all { value }
         primary { value }
@@ -41,48 +35,47 @@ query getDevicesState ($latencyTolerance: LatencyToleranceValue) {
         chrsIdentifier { entityId }
       }
       legacyAppliance { applianceId }
-      associatedUnits { id }
-      connections {
-          type
-          macAddress
-          bleMeshDeviceUuid
-      }
-      features(latencyToleranceValue: $latencyTolerance) {
+    }
+  }
+}
+"""
+
+QUERY_SENSOR_STATE = """
+query getEndpointState($endpointId: String!, $latencyTolerance: LatencyToleranceValue) {
+  endpoint(id: $endpointId) {
+    endpointId: id
+    features(latencyToleranceValue: $latencyTolerance) {
+      name
+      instance
+      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 { message }
-          __typename
-          ... on Illuminance {
-            illuminanceValue { value }
-            timeOfSample
-            timeOfLastChange
-          }
-          ... on Reachability {
-              reachabilityStatusValue
-              timeOfSample
-              timeOfLastChange
-          }
-          ... on DetectionState {
-              detectionStateValue
-              timeOfSample
-              timeOfLastChange
-          }
-          ... on Volume {
-              value { volValue: value }
-          }
-          ... on TemperatureSensor {
-              name
-              value {
-                value
-                scale
-              }
-              timeOfSample
-              timeOfLastChange
+          value {
+            value
+            scale
           }
+          timeOfSample
+          timeOfLastChange
         }
       }
     }

{aioamazondevices-6.2.8.dist-info → aioamazondevices-6.4.0.dist-info}/METADATA

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

aioamazondevices-6.4.0.dist-info/RECORD

@@ -0,0 +1,12 @@
+aioamazondevices/__init__.py,sha256=zz9ketTcgCPBPuHWcXvZG6yu5M4IxzEpRNRWvR4ETpc,276
+aioamazondevices/api.py,sha256=YX-3khyvvvWdsq3XE2Q1P3AzRtkw-juWoBC_qdnGA3g,49661
+aioamazondevices/const.py,sha256=A0aMbjPgIOAsSL20vjhAVkLBsi9QfkvL-1YAOEEa85I,11474
+aioamazondevices/exceptions.py,sha256=gRYrxNAJnrV6uRuMx5e76VMvtNKyceXd09q84pDBBrI,638
+aioamazondevices/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+aioamazondevices/query.py,sha256=SKn-fXFUnXnCvmKd6IvAGdkFL7sBzhYBEAZ0aZ2ez9E,1800
+aioamazondevices/sounds.py,sha256=CXMDk-KoKVFxBdVAw3MeOClqgpzcVDxvQhFOJp7qX-Y,1896
+aioamazondevices/utils.py,sha256=RzuKRhnq_8ymCoJMoQJ2vBYyuew06RSWpqQWmqdNczE,2019
+aioamazondevices-6.4.0.dist-info/METADATA,sha256=xuedY3lpMT_rHFMdPFRh6IgxMiSB_requRjwulwbxRE,7656
+aioamazondevices-6.4.0.dist-info/WHEEL,sha256=zp0Cn7JsFoX2ATtOhtaFYIiE2rmFAD4OcMhtUki8W3U,88
+aioamazondevices-6.4.0.dist-info/licenses/LICENSE,sha256=sS48k5sp9bFV-NSHDfAJuTZZ_-AP9ZDqUzQ9sffGlsg,11346
+aioamazondevices-6.4.0.dist-info/RECORD,,

aioamazondevices-6.2.8.dist-info/RECORD

@@ -1,12 +0,0 @@
-aioamazondevices/__init__.py,sha256=fC_cVxoQ9UV0g3MPcq9xo24JwXEXPPXuU1x5i1IA00o,276
-aioamazondevices/api.py,sha256=xJyDMmWDizrr4k8cpoUtr3FMb7A0K3y-ls9sbh3x0lw,44084
-aioamazondevices/const.py,sha256=pPjMhNABj3rN8uvHzqj41tDiGPx-C50QRcSckvzX9z8,11561
-aioamazondevices/exceptions.py,sha256=gRYrxNAJnrV6uRuMx5e76VMvtNKyceXd09q84pDBBrI,638
-aioamazondevices/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-aioamazondevices/query.py,sha256=qLCuNyVlSbvVQmckZUsmftsz8s04GIukdidsOo4BrD0,2084
-aioamazondevices/sounds.py,sha256=CXMDk-KoKVFxBdVAw3MeOClqgpzcVDxvQhFOJp7qX-Y,1896
-aioamazondevices/utils.py,sha256=RzuKRhnq_8ymCoJMoQJ2vBYyuew06RSWpqQWmqdNczE,2019
-aioamazondevices-6.2.8.dist-info/METADATA,sha256=HM04uPbCYPajVoqRxnrnywFsqV7YUmHDEupi0qWLd1k,7656
-aioamazondevices-6.2.8.dist-info/WHEEL,sha256=zp0Cn7JsFoX2ATtOhtaFYIiE2rmFAD4OcMhtUki8W3U,88
-aioamazondevices-6.2.8.dist-info/licenses/LICENSE,sha256=sS48k5sp9bFV-NSHDfAJuTZZ_-AP9ZDqUzQ9sffGlsg,11346
-aioamazondevices-6.2.8.dist-info/RECORD,,