aioamazondevices 11.0.1__tar.gz → 11.1.2__tar.gz

{aioamazondevices-11.0.1 → aioamazondevices-11.1.2}/PKG-INFO

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

{aioamazondevices-11.0.1 → aioamazondevices-11.1.2}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "aioamazondevices"
-version = "11.0.1"
+version = "11.1.2"
 requires-python = ">=3.12"
 description = "Python library to control Amazon devices"
 authors = [
@@ -36,7 +36,7 @@ dependencies = [
 [tool.poetry.group.dev.dependencies]
 pytest = "^9.0"
 pytest-cov = ">=5,<8"
-types-python-dateutil = "^2.9.0.20251115"
+types-python-dateutil = "^2.9.0.20260124"
 
 [tool.semantic_release]
 version_toml = ["pyproject.toml:project.version"]

{aioamazondevices-11.0.1 → aioamazondevices-11.1.2}/src/aioamazondevices/__init__.py

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

{aioamazondevices-11.0.1 → aioamazondevices-11.1.2}/src/aioamazondevices/api.py

@@ -9,6 +9,7 @@ from aiohttp import ClientSession
 
 from . import __version__
 from .const.devices import (
+    AQM_DEVICE_TYPE,
     DEVICE_TO_IGNORE,
     DEVICE_TYPE_TO_MODEL,
     SPEAKER_GROUP_FAMILY,
@@ -20,7 +21,7 @@ from .const.http import (
     URI_DEVICES,
     URI_NEXUS_GRAPHQL,
 )
-from .const.metadata import SENSORS
+from .const.metadata import ALEXA_INFO_SKILLS, AQM_RANGE_SENSORS, SENSORS
 from .const.queries import QUERY_DEVICE_DATA, QUERY_SENSOR_STATE
 from .const.schedules import (
     NOTIFICATION_ALARM,
@@ -164,12 +165,13 @@ class AmazonEchoApi:
         self, endpoint: dict[str, Any], serial_number: str
     ) -> dict[str, AmazonDeviceSensor]:
         device_sensors: dict[str, AmazonDeviceSensor] = {}
+        device = self._final_devices[serial_number]
         for feature in endpoint.get("features", {}):
             if (sensor_template := SENSORS.get(feature["name"])) is None:
                 # Skip sensors that are not in the predefined list
                 continue
 
-            if not (name := sensor_template["name"]):
+            if not (sensor_template_name_value := sensor_template["name"]):
                 raise CannotRetrieveData("Unable to read sensor template")
 
             for feature_property in feature.get("properties"):
@@ -190,7 +192,7 @@ class AmazonEchoApi:
                         if not value_raw:
                             _LOGGER.warning(
                                 "Sensor %s [device %s] ignored due to empty value",
-                                name,
+                                sensor_template_name_value,
                                 serial_number,
                             )
                             continue
@@ -208,26 +210,50 @@ class AmazonEchoApi:
                     except (KeyError, ValueError) as exc:
                         _LOGGER.warning(
                             "Sensor %s [device %s] ignored due to errors in feature %s: %s",  # noqa: E501
-                            name,
+                            sensor_template_name_value,
                             serial_number,
                             feature_property,
                             repr(exc),
                         )
                 if error:
                     _LOGGER.debug(
-                        "error in sensor %s - %s - %s", name, error_type, error_msg
-                    )
-
-                if error_type != "NOT_FOUND":
-                    device_sensors[name] = AmazonDeviceSensor(
-                        name,
-                        value,
-                        error,
+                        "error in sensor %s - %s - %s",
+                        sensor_template_name_value,
                         error_type,
                         error_msg,
-                        scale,
                     )
 
+                if error_type == "NOT_FOUND":
+                    continue
+
+                sensor_name = sensor_template_name_value
+
+                if (
+                    device.device_type == AQM_DEVICE_TYPE
+                    and sensor_template_name_value == "rangeValue"
+                ):
+                    if not (
+                        (instance := feature.get("instance"))
+                        and (aqm_sensor := AQM_RANGE_SENSORS.get(instance))
+                        and (aqm_sensor_name := aqm_sensor.get("name"))
+                    ):
+                        _LOGGER.debug(
+                            "No template for rangeValue (%s) - Skipping sensor",
+                            instance,
+                        )
+                        continue
+                    sensor_name = aqm_sensor_name
+                    scale = aqm_sensor.get("scale")
+
+                device_sensors[sensor_name] = AmazonDeviceSensor(
+                    sensor_name,
+                    value,
+                    error,
+                    error_type,
+                    error_msg,
+                    scale,
+                )
+
         return device_sensors
 
     async def _get_devices_endpoint_data(self) -> dict[str, dict[str, Any]]:
@@ -247,13 +273,15 @@ class AmazonEchoApi:
 
         endpoint_data = await self._http_wrapper.response_to_json(raw_resp, "endpoint")
 
-        if not (data := endpoint_data.get("data")) or not data.get("listEndpoints"):
+        if not (data := endpoint_data.get("data")) or not data.get("alexaVoiceDevices"):
             await self._format_human_error(endpoint_data)
             return {}
 
-        endpoints = data["listEndpoints"]
         devices_endpoints: dict[str, dict[str, Any]] = {}
-        for endpoint in endpoints.get("endpoints"):
+
+        # Process Alexa Voice Enabled devices
+        # Just map endpoint ID to serial number to facilitate sensor lookup
+        for endpoint in data.get("alexaVoiceDevices", {}).get("endpoints", {}):
             # save looking up sensor data on apps
             if endpoint.get("alexaEnabledMetadata", {}).get("category") == "APP":
                 continue
@@ -263,6 +291,39 @@ class AmazonEchoApi:
                 devices_endpoints[serial_number] = endpoint
                 self._endpoints[endpoint["endpointId"]] = serial_number
 
+        # Process Air Quality Monitors if present
+        # map endpoint ID to serial number to facilitate sensor lookup but also
+        # create AmazonDevice as these are not present in api/devices-v2/device endpoint
+        for aqm_endpoint in data.get("airQualityMonitors", {}).get("endpoints", {}):
+            aqm_serial_number: str = aqm_endpoint["serialNumber"]["value"]["text"]
+            devices_endpoints[aqm_serial_number] = aqm_endpoint
+            self._endpoints[aqm_endpoint["endpointId"]] = aqm_serial_number
+
+            device_name = aqm_endpoint["friendlyNameObject"]["value"]["text"]
+            device_type = aqm_endpoint["legacyIdentifiers"]["dmsIdentifier"][
+                "deviceType"
+            ]["value"]["text"]
+            software_version = aqm_endpoint["softwareVersion"]["value"]["text"]
+
+            self._final_devices[aqm_serial_number] = AmazonDevice(
+                account_name=device_name,
+                capabilities=[],
+                device_family="AIR_QUALITY_MONITOR",
+                device_type=device_type,
+                device_owner_customer_id=self._session_state_data.account_customer_id
+                or "n/a",
+                household_device=False,
+                device_cluster_members={aqm_serial_number: AQM_DEVICE_TYPE},
+                online=True,
+                serial_number=aqm_serial_number,
+                software_version=software_version,
+                entity_id=None,
+                endpoint_id=aqm_endpoint.get("endpointId"),
+                sensors={},
+                notifications_supported=False,
+                notifications={},
+            )
+
         return devices_endpoints
 
     async def get_devices_data(
@@ -307,9 +368,15 @@ class AmazonEchoApi:
             sensors = devices_sensors.get(device.serial_number, {})
             if sensors:
                 device.sensors = sensors
+                if reachability_sensor := sensors.get("reachability"):
+                    device.online = reachability_sensor.value == "OK"
+                else:
+                    device.online = False
             else:
+                device.online = False
                 for device_sensor in device.sensors.values():
                     device_sensor.error = True
+
             if (
                 device_dnd := dnd_sensors.get(device.serial_number)
             ) and device.device_family != SPEAKER_GROUP_FAMILY:
@@ -341,6 +408,15 @@ class AmazonEchoApi:
                 ):
                     device.notifications[notification_type] = notification_object
 
+        # base online status of speaker groups on their members
+        for device in self._final_devices.values():
+            if device.device_family == SPEAKER_GROUP_FAMILY:
+                device.online = all(
+                    d.online
+                    for d in self._final_devices.values()
+                    if d.serial_number in device.device_cluster_members
+                )
+
     async def _set_device_endpoints_data(self) -> None:
         """Set device endpoint data."""
         devices_endpoints = await self._get_devices_endpoint_data()
@@ -382,6 +458,11 @@ class AmazonEchoApi:
 
             serial_number: str = device["serialNumber"]
 
+            _has_notification_capability = any(
+                capability in capabilities
+                for capability in ["REMINDERS", "TIMERS_AND_ALARMS"]
+            )
+
             final_devices_list[serial_number] = AmazonDevice(
                 account_name=account_name,
                 capabilities=capabilities,
@@ -399,6 +480,7 @@ class AmazonEchoApi:
                 entity_id=None,
                 endpoint_id=None,
                 sensors={},
+                notifications_supported=_has_notification_capability,
                 notifications={},
             )
 
@@ -453,7 +535,7 @@ class AmazonEchoApi:
         sound_name: str,
     ) -> None:
         """Call Alexa.Sound to play sound."""
-        await self._sequence_handler.send_message(
+        await self._call_alexa_command_per_cluster_member(
             device, AmazonSequenceType.Sound, sound_name
         )
 
@@ -474,7 +556,7 @@ class AmazonEchoApi:
         text_command: str,
     ) -> None:
         """Call Alexa.TextCommand to issue command."""
-        await self._sequence_handler.send_message(
+        await self._call_alexa_command_per_cluster_member(
             device, AmazonSequenceType.TextCommand, text_command
         )
 
@@ -484,7 +566,7 @@ class AmazonEchoApi:
         skill_name: str,
     ) -> None:
         """Call Alexa.LaunchSkill to launch a skill."""
-        await self._sequence_handler.send_message(
+        await self._call_alexa_command_per_cluster_member(
             device, AmazonSequenceType.LaunchSkill, skill_name
         )
 
@@ -494,7 +576,22 @@ class AmazonEchoApi:
         info_skill_name: str,
     ) -> None:
         """Call Info skill.  See ALEXA_INFO_SKILLS . const."""
-        await self._sequence_handler.send_message(device, info_skill_name, "")
+        info_skill = ALEXA_INFO_SKILLS.get(info_skill_name, info_skill_name)
+        await self._call_alexa_command_per_cluster_member(device, info_skill, "")
+
+    async def _call_alexa_command_per_cluster_member(
+        self,
+        device: AmazonDevice,
+        message_type: str,
+        message_body: str,
+    ) -> None:
+        """Call Alexa command per cluster member."""
+        for cluster_member in device.device_cluster_members:
+            await self._sequence_handler.send_message(
+                self._final_devices[cluster_member],
+                message_type,
+                message_body,
+            )
 
     async def _format_human_error(self, sensors_state: dict) -> bool:
         """Format human readable error from malformed data."""

{aioamazondevices-11.0.1 → aioamazondevices-11.1.2}/src/aioamazondevices/const/devices.py

@@ -4,6 +4,7 @@ from .http import AMAZON_DEVICE_TYPE
 
 SPEAKER_GROUP_FAMILY = "WHA"
 SPEAKER_GROUP_MODEL = "Speaker Group"
+AQM_DEVICE_TYPE = "AEZME1X38KDRA"
 
 DEVICE_TO_IGNORE: list[str] = [
     AMAZON_DEVICE_TYPE,  # Alexa App for iOS
@@ -28,10 +29,15 @@ DEVICE_TO_IGNORE: list[str] = [
     "A3BW5ZVFHRCQPO",  # BMW Mini Car System - issue #479
     "A133UZ2CB0IB8",  # Sony Soundbar Sony HT-A5000 - issue #486
     "A2M9HB23M9MSSM",  # Smartwatch Amazfit Bip U Pro - issue #507
+    "A2QDHDQIWC2LTG",  # Echo Buds (Left) - issue #515
+    "A31PMVIWCRNTX2",  # Echo Buds (Right) - issue #515
+    "A3HVREY4JWAZ6K",  # Echo Buds (Charger) - issue #515
     "A1P7E7V3FCZKU6",  # Toshiba Corporation TV 32LF221U19 - issue #531
+    "APHEAY6LX7T13",  # Samsung Refrigerator RS22T5561SR/AA - issue #577
     "A1NPP2J03FTS0I",  # Eero Pro 6 - issue #602
     "A14AIWB3T3AS1Z",  # Samsung Soundbar HW-Q950A - issue #603
-    "APHEAY6LX7T13",  # Samsung Refrigerator RS22T5561SR/AA - issue #577
+    "A1X5IB2CRN3E8G",  # Fitbit Versa 3 - issue #651
+    "A1NQ0LXWBGVQS9",  # Samsung 2012 QLED TV - Issue #660
 ]
 
 DEVICE_TYPE_TO_MODEL: dict[str, dict[str, str | None]] = {
@@ -426,4 +432,23 @@ DEVICE_TYPE_TO_MODEL: dict[str, dict[str, str | None]] = {
         "model": "Orbi Voice (RBS40V)",
         "hw_version": None,
     },
+    AQM_DEVICE_TYPE: {
+        "model": "Air Quality Monitor",
+        "hw_version": "Gen1",
+    },
+    "A1MR3F8QRZNAXI": {
+        "model": "Echo Dot Max",
+        "hw_version": "Gen1",
+    },
+    "A1XULUOD31VLF4": {
+        "manufacturer": "Broan-NuTone LLC",
+        "model": "Bathroom Fan with Alexa (VC110CCT)",
+        "hw_version": None,
+    },
+    "A15QWUTQ6FSMYX": {
+        # This appears to be a group for both speakers
+        # but four devices show this device type (see issue #515)
+        "model": "Echo Buds",
+        "hw_version": "Gen2",
+    },
 }

aioamazondevices-11.1.2/src/aioamazondevices/const/metadata.py

@@ -0,0 +1,86 @@
+"""aioamazondevices Additional entities const."""
+
+SENSOR_STATE_OFF = "NOT_DETECTED"
+
+SENSORS: dict[str, dict[str, str | None]] = {
+    "temperatureSensor": {
+        "name": "temperature",
+        "key": "value",
+        "subkey": "value",
+        "scale": "scale",
+    },
+    "motionSensor": {
+        "name": "detectionState",
+        "key": "detectionStateValue",
+        "subkey": None,
+        "scale": None,
+    },
+    "lightSensor": {
+        "name": "illuminance",
+        "key": "illuminanceValue",
+        "subkey": "value",
+        "scale": None,
+    },
+    "connectivity": {
+        "name": "reachability",
+        "key": "reachabilityStatusValue",
+        "subkey": None,
+        "scale": None,
+    },
+    "range": {
+        "name": "rangeValue",
+        "key": "rangeValue",
+        "subkey": "value",
+        "scale": None,
+    },
+}
+
+AQM_RANGE_SENSORS: dict[str, dict[str, str | None]] = {
+    "4": {
+        "name": "Humidity",
+        "scale": "%",
+    },
+    "5": {
+        "name": "VOC",
+        "scale": None,
+    },
+    "6": {
+        "name": "PM25",
+        "scale": "MicroGramsPerCubicMeter",
+    },
+    "7": {
+        "name": "PM10",
+        "scale": "MicroGramsPerCubicMeter",
+    },
+    "8": {
+        "name": "CO",
+        "scale": "ppm",
+    },
+    "9": {
+        "name": "Air Quality",
+        "scale": None,
+    },
+}
+
+
+ALEXA_INFO_SKILLS = {
+    "alexa_calendar_today": "Alexa.Calendar.PlayToday",
+    "alexa_calendar_tomorrow": "Alexa.Calendar.PlayTomorrow",
+    "alexa_calendar_next": "Alexa.Calendar.PlayNext",
+    "alexa_date": "Alexa.Date.Play",
+    "alexa_time": "Alexa.Time.Play",
+    "alexa_nationalnews": "Alexa.News.NationalNews",
+    "alexa_flashbriefing": "Alexa.FlashBriefing.Play",
+    "alexa_traffic": "Alexa.Traffic.Play",
+    "alexa_weather": "Alexa.Weather.Play",
+    "alexa_cleanup": "Alexa.CleanUp.Play",
+    "alexa_goodmorning": "Alexa.GoodMorning.Play",
+    "alexa_singasong": "Alexa.SingASong.Play",
+    "alexa_funfact": "Alexa.FunFact.Play",
+    "alexa_joke": "Alexa.Joke.Play",
+    "alexa_tellstory": "Alexa.TellStory.Play",
+    "alexa_imhome": "Alexa.ImHome.Play",
+    "alexa_goodnight": "Alexa.GoodNight.Play",
+}
+
+MAX_CUSTOMER_ACCOUNT_RETRIES = 3

{aioamazondevices-11.0.1 → aioamazondevices-11.1.2}/src/aioamazondevices/const/queries.py

@@ -2,40 +2,50 @@
 
 QUERY_DEVICE_DATA = """
 query getDevicesBaseData {
-  listEndpoints(
+  alexaVoiceDevices: listEndpoints(
     listEndpointsInput: {
-        displayCategory: "ALEXA_VOICE_ENABLED"
-        includeHouseholdDevices: true
+      displayCategory: "ALEXA_VOICE_ENABLED"
+      includeHouseholdDevices: true
     }
-  )
-  {
-    endpoints {
-      endpointId: id
-      friendlyNameObject { value { text } }
-      manufacturer { value { text } }
-      model { value { text} }
-      serialNumber { value { text } }
-      softwareVersion { value { text } }
-      creationTime
-      enablement
-      displayCategories {
-        all { value }
-        primary { value }
-      }
-      alexaEnabledMetadata {
-        iconId
-        isVisible
-        category
-        capabilities
-      }
-      legacyIdentifiers {
-        dmsIdentifier {
-          deviceType { value { text } }
-        }
-        chrsIdentifier { entityId }
-      }
-      legacyAppliance { applianceId }
+  ) {
+    ...DeviceEndpoints
+  }
+
+  airQualityMonitors: listEndpoints(
+    listEndpointsInput: {
+      displayCategory: "AIR_QUALITY_MONITOR"
+      includeHouseholdDevices: true
     }
+  ) {
+    ...DeviceEndpoints
+  }
+}
+
+fragment DeviceEndpoints on ListEndpointsResponse {
+  endpoints {
+    endpointId: id
+    friendlyNameObject { value { text } }
+    manufacturer { value { text } }
+    model { value { text } }
+    serialNumber { value { text } }
+    softwareVersion { value { text } }
+    creationTime
+    enablement
+    displayCategories {
+      all { value }
+      primary { value }
+    }
+    alexaEnabledMetadata {
+      iconId
+      isVisible
+      category
+      capabilities
+    }
+    legacyIdentifiers {
+      dmsIdentifier { deviceType { value { text } } }
+      chrsIdentifier { entityId }
+    }
+    legacyAppliance { applianceId }
   }
 }
 """
@@ -46,6 +56,7 @@ fragment EndpointState on Endpoint {
   friendlyNameObject { value { text } }
   features {
     name
+    instance
     properties {
       name
       type
@@ -76,6 +87,11 @@ fragment EndpointState on Endpoint {
         timeOfSample
         timeOfLastChange
       }
+      ... on RangeValue {
+        rangeValue { value }
+        timeOfSample
+        timeOfLastChange
+      }
     }
   }
 }

{aioamazondevices-11.0.1 → aioamazondevices-11.1.2}/src/aioamazondevices/http_wrapper.py

@@ -371,6 +371,7 @@ class AmazonHttpWrapper:
             ]:
                 raise CannotAuthenticate(await self.http_phrase_error(resp.status))
             if not await self._ignore_ap_signin_error(resp):
+                _LOGGER.debug("Error response content: %s", await resp.text())
                 raise CannotRetrieveData(
                     f"Request failed: {await self.http_phrase_error(resp.status)}"
                 )

{aioamazondevices-11.0.1 → aioamazondevices-11.1.2}/src/aioamazondevices/implementation/sequence.py

@@ -123,7 +123,7 @@ class AmazonSequenceHandler:
                     "uri": "connection://AMAZON.Launch/" + message_body,
                 },
             }
-        elif message_type in ALEXA_INFO_SKILLS:
+        elif message_type in ALEXA_INFO_SKILLS.values():
             payload = {
                 **base_payload,
             }

{aioamazondevices-11.0.1 → aioamazondevices-11.1.2}/src/aioamazondevices/structures.py

@@ -44,6 +44,7 @@ class AmazonDevice:
     entity_id: str | None
     endpoint_id: str | None
     sensors: dict[str, AmazonDeviceSensor]
+    notifications_supported: bool
     notifications: dict[str, AmazonSchedule]
 
 

aioamazondevices-11.0.1/src/aioamazondevices/const/metadata.py

@@ -1,46 +0,0 @@
-"""aioamazondevices Additional entities const."""
-
-SENSOR_STATE_OFF = "NOT_DETECTED"
-
-SENSORS: dict[str, dict[str, str | None]] = {
-    "temperatureSensor": {
-        "name": "temperature",
-        "key": "value",
-        "subkey": "value",
-        "scale": "scale",
-    },
-    "motionSensor": {
-        "name": "detectionState",
-        "key": "detectionStateValue",
-        "subkey": None,
-        "scale": None,
-    },
-    "lightSensor": {
-        "name": "illuminance",
-        "key": "illuminanceValue",
-        "subkey": "value",
-        "scale": None,
-    },
-}
-
-ALEXA_INFO_SKILLS = [
-    "Alexa.Calendar.PlayToday",
-    "Alexa.Calendar.PlayTomorrow",
-    "Alexa.Calendar.PlayNext",
-    "Alexa.Date.Play",
-    "Alexa.Time.Play",
-    "Alexa.News.NationalNews",
-    "Alexa.FlashBriefing.Play",
-    "Alexa.Traffic.Play",
-    "Alexa.Weather.Play",
-    "Alexa.CleanUp.Play",
-    "Alexa.GoodMorning.Play",
-    "Alexa.SingASong.Play",
-    "Alexa.FunFact.Play",
-    "Alexa.Joke.Play",
-    "Alexa.TellStory.Play",
-    "Alexa.ImHome.Play",
-    "Alexa.GoodNight.Play",
-]
-
-MAX_CUSTOMER_ACCOUNT_RETRIES = 3