aioamazondevices 9.0.3__tar.gz → 11.0.1__tar.gz

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

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

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

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

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

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

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

@@ -5,10 +5,7 @@ from datetime import UTC, datetime, timedelta
 from http import HTTPMethod
 from typing import Any
 
-import orjson
 from aiohttp import ClientSession
-from dateutil.parser import parse
-from dateutil.rrule import rrulestr
 
 from . import __version__
 from .const.devices import (
@@ -19,33 +16,29 @@ from .const.devices import (
 from .const.http import (
     ARRAY_WRAPPER,
     DEFAULT_SITE,
+    REQUEST_AGENT,
     URI_DEVICES,
-    URI_DND,
     URI_NEXUS_GRAPHQL,
-    URI_NOTIFICATIONS,
 )
-from .const.metadata import ALEXA_INFO_SKILLS, SENSORS
+from .const.metadata import SENSORS
 from .const.queries import QUERY_DEVICE_DATA, QUERY_SENSOR_STATE
 from .const.schedules import (
-    COUNTRY_GROUPS,
     NOTIFICATION_ALARM,
-    NOTIFICATION_MUSIC_ALARM,
     NOTIFICATION_REMINDER,
     NOTIFICATION_TIMER,
-    NOTIFICATIONS_SUPPORTED,
-    RECURRING_PATTERNS,
-    WEEKEND_EXCEPTIONS,
 )
 from .exceptions import (
     CannotRetrieveData,
 )
 from .http_wrapper import AmazonHttpWrapper, AmazonSessionStateData
+from .implementation.dnd import AmazonDnDHandler
+from .implementation.notification import AmazonNotificationHandler
+from .implementation.sequence import AmazonSequenceHandler
 from .login import AmazonLogin
 from .structures import (
     AmazonDevice,
     AmazonDeviceSensor,
     AmazonMusicSource,
-    AmazonSchedule,
     AmazonSequenceType,
 )
 from .utils import _LOGGER
@@ -85,7 +78,19 @@ class AmazonEchoApi:
             session_state_data=self._session_state_data,
         )
 
-        self._list_for_clusters: dict[str, str] = {}
+        self._notification_handler = AmazonNotificationHandler(
+            http_wrapper=self._http_wrapper,
+            session_state_data=self._session_state_data,
+        )
+
+        self._sequence_handler = AmazonSequenceHandler(
+            http_wrapper=self._http_wrapper,
+            session_state_data=self._session_state_data,
+        )
+
+        self._dnd_handler = AmazonDnDHandler(
+            http_wrapper=self._http_wrapper, session_state_data=self._session_state_data
+        )
 
         self._final_devices: dict[str, AmazonDevice] = {}
         self._endpoints: dict[str, str] = {}  # endpoint ID to serial number map
@@ -127,6 +132,7 @@ class AmazonEchoApi:
             url=f"https://alexa.amazon.{self._session_state_data.domain}{URI_NEXUS_GRAPHQL}",
             input_data=payload,
             json_data=True,
+            extended_headers={"User-Agent": REQUEST_AGENT["Amazon"]},
         )
 
         sensors_state = await self._http_wrapper.response_to_json(raw_resp, "sensors")
@@ -236,6 +242,7 @@ class AmazonEchoApi:
             url=f"https://alexa.amazon.{self._session_state_data.domain}{URI_NEXUS_GRAPHQL}",
             input_data=payload,
             json_data=True,
+            extended_headers={"User-Agent": REQUEST_AGENT["Amazon"]},
         )
 
         endpoint_data = await self._http_wrapper.response_to_json(raw_resp, "endpoint")
@@ -258,190 +265,6 @@ class AmazonEchoApi:
 
         return devices_endpoints
 
-    async def _get_notifications(self) -> dict[str, dict[str, AmazonSchedule]] | None:
-        final_notifications: dict[str, dict[str, AmazonSchedule]] = {}
-
-        try:
-            _, raw_resp = await self._http_wrapper.session_request(
-                HTTPMethod.GET,
-                url=f"https://alexa.amazon.{self._session_state_data.domain}{URI_NOTIFICATIONS}",
-            )
-        except CannotRetrieveData:
-            _LOGGER.warning(
-                "Failed to obtain notification data.  Timers and alarms have not been updated"  # noqa: E501
-            )
-            return None
-
-        notifications = await self._http_wrapper.response_to_json(
-            raw_resp, "notifications"
-        )
-
-        for schedule in notifications["notifications"]:
-            schedule_type: str = schedule["type"]
-            schedule_device_type = schedule["deviceType"]
-            schedule_device_serial = schedule["deviceSerialNumber"]
-
-            if schedule_device_type in DEVICE_TO_IGNORE:
-                continue
-
-            if schedule_type not in NOTIFICATIONS_SUPPORTED:
-                _LOGGER.debug(
-                    "Unsupported schedule type %s for device %s",
-                    schedule_type,
-                    schedule_device_serial,
-                )
-                continue
-
-            if schedule_type == NOTIFICATION_MUSIC_ALARM:
-                # Structure is the same as standard Alarm
-                schedule_type = NOTIFICATION_ALARM
-                schedule["type"] = NOTIFICATION_ALARM
-            label_desc = schedule_type.lower() + "Label"
-            if (schedule_status := schedule["status"]) == "ON" and (
-                next_occurrence := await self._parse_next_occurence(schedule)
-            ):
-                schedule_notification_list = final_notifications.get(
-                    schedule_device_serial, {}
-                )
-                schedule_notification_by_type = schedule_notification_list.get(
-                    schedule_type
-                )
-                # Replace if no existing notification
-                # or if existing.next_occurrence is None
-                # or if new next_occurrence is earlier
-                if (
-                    not schedule_notification_by_type
-                    or schedule_notification_by_type.next_occurrence is None
-                    or next_occurrence < schedule_notification_by_type.next_occurrence
-                ):
-                    final_notifications.update(
-                        {
-                            schedule_device_serial: {
-                                **schedule_notification_list
-                                | {
-                                    schedule_type: AmazonSchedule(
-                                        type=schedule_type,
-                                        status=schedule_status,
-                                        label=schedule[label_desc],
-                                        next_occurrence=next_occurrence,
-                                    ),
-                                }
-                            }
-                        }
-                    )
-
-        return final_notifications
-
-    async def _parse_next_occurence(
-        self,
-        schedule: dict[str, Any],
-    ) -> datetime | None:
-        """Parse RFC5545 rule set for next iteration."""
-        # Local timezone
-        tzinfo = datetime.now().astimezone().tzinfo
-        # Current time
-        actual_time = datetime.now(tz=tzinfo)
-        # Reference start date
-        today_midnight = actual_time.replace(hour=0, minute=0, second=0, microsecond=0)
-        # Reference time (1 minute ago to avoid edge cases)
-        now_reference = actual_time - timedelta(minutes=1)
-
-        # Schedule data
-        original_date = schedule.get("originalDate")
-        original_time = schedule.get("originalTime")
-
-        recurring_rules: list[str] = []
-        if schedule.get("rRuleData"):
-            recurring_rules = schedule["rRuleData"]["recurrenceRules"]
-        if schedule.get("recurringPattern"):
-            recurring_rules.append(schedule["recurringPattern"])
-
-        # Recurring events
-        if recurring_rules:
-            next_candidates: list[datetime] = []
-            for recurring_rule in recurring_rules:
-                # Already in RFC5545 format
-                if "FREQ=" in recurring_rule:
-                    rule = await self._add_hours_minutes(recurring_rule, original_time)
-
-                    # Add date to candidates list
-                    next_candidates.append(
-                        rrulestr(rule, dtstart=today_midnight).after(
-                            now_reference, True
-                        ),
-                    )
-                    continue
-
-                if recurring_rule not in RECURRING_PATTERNS:
-                    _LOGGER.warning(
-                        "Unknown recurring rule <%s> for schedule type <%s>",
-                        recurring_rule,
-                        schedule["type"],
-                    )
-                    return None
-
-                # Adjust recurring rules for country specific weekend exceptions
-                recurring_pattern = RECURRING_PATTERNS.copy()
-                for group, countries in COUNTRY_GROUPS.items():
-                    if self._session_state_data.country_code in countries:
-                        recurring_pattern |= WEEKEND_EXCEPTIONS[group]
-                        break
-
-                rule = await self._add_hours_minutes(
-                    recurring_pattern[recurring_rule], original_time
-                )
-
-                # Add date to candidates list
-                next_candidates.append(
-                    rrulestr(rule, dtstart=today_midnight).after(now_reference, True),
-                )
-
-            return min(next_candidates) if next_candidates else None
-
-        # Single events
-        if schedule["type"] == NOTIFICATION_ALARM:
-            timestamp = parse(f"{original_date} {original_time}").replace(tzinfo=tzinfo)
-
-        elif schedule["type"] == NOTIFICATION_TIMER:
-            # API returns triggerTime in milliseconds since epoch
-            timestamp = datetime.fromtimestamp(
-                schedule["triggerTime"] / 1000, tz=tzinfo
-            )
-
-        elif schedule["type"] == NOTIFICATION_REMINDER:
-            # API returns alarmTime in milliseconds since epoch
-            timestamp = datetime.fromtimestamp(schedule["alarmTime"] / 1000, tz=tzinfo)
-
-        else:
-            _LOGGER.warning(("Unknown schedule type: %s"), schedule["type"])
-            return None
-
-        if timestamp > now_reference:
-            return timestamp
-
-        return None
-
-    async def _add_hours_minutes(
-        self,
-        recurring_rule: str,
-        original_time: str | None,
-    ) -> str:
-        """Add hours and minutes to a RFC5545 string."""
-        rule = recurring_rule.removesuffix(";")
-
-        if not original_time:
-            return rule
-
-        # Add missing BYHOUR, BYMINUTE if needed (Alarms only)
-        if "BYHOUR=" not in recurring_rule:
-            hour = int(original_time.split(":")[0])
-            rule += f";BYHOUR={hour}"
-        if "BYMINUTE=" not in recurring_rule:
-            minute = int(original_time.split(":")[1])
-            rule += f";BYMINUTE={minute}"
-
-        return rule
-
     async def get_devices_data(
         self,
     ) -> dict[str, AmazonDevice]:
@@ -477,8 +300,8 @@ class AmazonEchoApi:
 
     async def _get_sensor_data(self) -> None:
         devices_sensors = await self._get_sensors_states()
-        dnd_sensors = await self._get_dnd_status()
-        notifications = await self._get_notifications()
+        dnd_sensors = await self._dnd_handler.get_do_not_disturb_status()
+        notifications = await self._notification_handler.get_notifications()
         for device in self._final_devices.values():
             # Update sensors
             sensors = devices_sensors.get(device.serial_number, {})
@@ -542,6 +365,7 @@ class AmazonEchoApi:
         json_data = await self._http_wrapper.response_to_json(raw_resp, "devices")
 
         final_devices_list: dict[str, AmazonDevice] = {}
+        serial_to_device_type: dict[str, str] = {}
         for device in json_data["devices"]:
             # Remove stale, orphaned and virtual devices
             if not device or (device.get("deviceType") in DEVICE_TO_IGNORE):
@@ -566,7 +390,9 @@ class AmazonEchoApi:
                 device_owner_customer_id=device["deviceOwnerCustomerId"],
                 household_device=device["deviceOwnerCustomerId"]
                 == self._session_state_data.account_customer_id,
-                device_cluster_members=(device["clusterMembers"] or [serial_number]),
+                device_cluster_members=dict.fromkeys(
+                    device["clusterMembers"] or [serial_number]
+                ),
                 online=device["online"],
                 serial_number=serial_number,
                 software_version=device["softwareVersion"],
@@ -576,12 +402,14 @@ class AmazonEchoApi:
                 notifications={},
             )
 
-        self._list_for_clusters.update(
-            {
-                device.serial_number: device.device_type
-                for device in final_devices_list.values()
-            }
-        )
+            serial_to_device_type[serial_number] = device["deviceType"]
+
+        # backfill device types for cluster members
+        for device in final_devices_list.values():
+            for member_serial in device.device_cluster_members:
+                device.device_cluster_members[member_serial] = (
+                    serial_to_device_type.get(member_serial)
+                )
 
         self._final_devices = final_devices_list
 
@@ -599,239 +427,74 @@ class AmazonEchoApi:
 
         return model_details
 
-    async def _send_message(
-        self,
-        device: AmazonDevice,
-        message_type: str,
-        message_body: str,
-        message_source: AmazonMusicSource | None = None,
-    ) -> None:
-        """Send message to specific device."""
-        if not self._session_state_data.login_stored_data:
-            _LOGGER.warning("No login data available, cannot send message")
-            return
-
-        base_payload = {
-            "deviceType": device.device_type,
-            "deviceSerialNumber": device.serial_number,
-            "locale": self._session_state_data.language,
-            "customerId": self._session_state_data.account_customer_id,
-        }
-
-        payload: dict[str, Any]
-        if message_type == AmazonSequenceType.Speak:
-            payload = {
-                **base_payload,
-                "textToSpeak": message_body,
-                "target": {
-                    "customerId": self._session_state_data.account_customer_id,
-                    "devices": [
-                        {
-                            "deviceSerialNumber": device.serial_number,
-                            "deviceTypeId": device.device_type,
-                        },
-                    ],
-                },
-                "skillId": "amzn1.ask.1p.saysomething",
-            }
-        elif message_type == AmazonSequenceType.Announcement:
-            playback_devices: list[dict[str, str]] = [
-                {
-                    "deviceSerialNumber": serial,
-                    "deviceTypeId": self._list_for_clusters[serial],
-                }
-                for serial in device.device_cluster_members
-                if serial in self._list_for_clusters
-            ]
-
-            payload = {
-                **base_payload,
-                "expireAfter": "PT5S",
-                "content": [
-                    {
-                        "locale": self._session_state_data.language,
-                        "display": {
-                            "title": "Home Assistant",
-                            "body": message_body,
-                        },
-                        "speak": {
-                            "type": "text",
-                            "value": message_body,
-                        },
-                    }
-                ],
-                "target": {
-                    "customerId": self._session_state_data.account_customer_id,
-                    "devices": playback_devices,
-                },
-                "skillId": "amzn1.ask.1p.routines.messaging",
-            }
-        elif message_type == AmazonSequenceType.Sound:
-            payload = {
-                **base_payload,
-                "soundStringId": message_body,
-                "skillId": "amzn1.ask.1p.sound",
-            }
-        elif message_type == AmazonSequenceType.Music:
-            payload = {
-                **base_payload,
-                "searchPhrase": message_body,
-                "sanitizedSearchPhrase": message_body,
-                "musicProviderId": message_source,
-            }
-        elif message_type == AmazonSequenceType.TextCommand:
-            payload = {
-                **base_payload,
-                "skillId": "amzn1.ask.1p.tellalexa",
-                "text": message_body,
-            }
-        elif message_type == AmazonSequenceType.LaunchSkill:
-            payload = {
-                **base_payload,
-                "targetDevice": {
-                    "deviceType": device.device_type,
-                    "deviceSerialNumber": device.serial_number,
-                },
-                "connectionRequest": {
-                    "uri": "connection://AMAZON.Launch/" + message_body,
-                },
-            }
-        elif message_type in ALEXA_INFO_SKILLS:
-            payload = {
-                **base_payload,
-            }
-        else:
-            raise ValueError(f"Message type <{message_type}> is not recognised")
-
-        sequence = {
-            "@type": "com.amazon.alexa.behaviors.model.Sequence",
-            "startNode": {
-                "@type": "com.amazon.alexa.behaviors.model.SerialNode",
-                "nodesToExecute": [
-                    {
-                        "@type": "com.amazon.alexa.behaviors.model.OpaquePayloadOperationNode",  # noqa: E501
-                        "type": message_type,
-                        "operationPayload": payload,
-                    },
-                ],
-            },
-        }
-
-        node_data = {
-            "behaviorId": "PREVIEW",
-            "sequenceJson": orjson.dumps(sequence).decode("utf-8"),
-            "status": "ENABLED",
-        }
-
-        _LOGGER.debug("Preview data payload: %s", node_data)
-        await self._http_wrapper.session_request(
-            method=HTTPMethod.POST,
-            url=f"https://alexa.amazon.{self._session_state_data.domain}/api/behaviors/preview",
-            input_data=node_data,
-            json_data=True,
-        )
-
-        return
-
     async def call_alexa_speak(
         self,
         device: AmazonDevice,
-        message_body: str,
+        text_to_speak: str,
     ) -> None:
         """Call Alexa.Speak to send a message."""
-        return await self._send_message(device, AmazonSequenceType.Speak, message_body)
+        await self._sequence_handler.send_message(
+            device, AmazonSequenceType.Speak, text_to_speak
+        )
 
     async def call_alexa_announcement(
         self,
         device: AmazonDevice,
-        message_body: str,
+        text_to_announce: str,
     ) -> None:
         """Call AlexaAnnouncement to send a message."""
-        return await self._send_message(
-            device, AmazonSequenceType.Announcement, message_body
+        await self._sequence_handler.send_message(
+            device, AmazonSequenceType.Announcement, text_to_announce
         )
 
     async def call_alexa_sound(
         self,
         device: AmazonDevice,
-        message_body: str,
+        sound_name: str,
     ) -> None:
         """Call Alexa.Sound to play sound."""
-        return await self._send_message(device, AmazonSequenceType.Sound, message_body)
+        await self._sequence_handler.send_message(
+            device, AmazonSequenceType.Sound, sound_name
+        )
 
     async def call_alexa_music(
         self,
         device: AmazonDevice,
-        message_body: str,
-        message_source: AmazonMusicSource,
+        search_phrase: str,
+        music_source: AmazonMusicSource,
     ) -> None:
         """Call Alexa.Music.PlaySearchPhrase to play music."""
-        return await self._send_message(
-            device, AmazonSequenceType.Music, message_body, message_source
+        await self._sequence_handler.send_message(
+            device, AmazonSequenceType.Music, search_phrase, music_source
         )
 
     async def call_alexa_text_command(
         self,
         device: AmazonDevice,
-        message_body: str,
+        text_command: str,
     ) -> None:
         """Call Alexa.TextCommand to issue command."""
-        return await self._send_message(
-            device, AmazonSequenceType.TextCommand, message_body
+        await self._sequence_handler.send_message(
+            device, AmazonSequenceType.TextCommand, text_command
         )
 
     async def call_alexa_skill(
         self,
         device: AmazonDevice,
-        message_body: str,
+        skill_name: str,
     ) -> None:
         """Call Alexa.LaunchSkill to launch a skill."""
-        return await self._send_message(
-            device, AmazonSequenceType.LaunchSkill, message_body
+        await self._sequence_handler.send_message(
+            device, AmazonSequenceType.LaunchSkill, skill_name
         )
 
     async def call_alexa_info_skill(
         self,
         device: AmazonDevice,
-        message_type: str,
+        info_skill_name: str,
     ) -> None:
         """Call Info skill.  See ALEXA_INFO_SKILLS . const."""
-        return await self._send_message(device, message_type, "")
-
-    async def set_do_not_disturb(self, device: AmazonDevice, state: bool) -> None:
-        """Set do_not_disturb flag."""
-        payload = {
-            "deviceSerialNumber": device.serial_number,
-            "deviceType": device.device_type,
-            "enabled": state,
-        }
-        url = f"https://alexa.amazon.{self._session_state_data.domain}/api/dnd/status"
-        await self._http_wrapper.session_request(
-            method="PUT",
-            url=url,
-            input_data=payload,
-            json_data=True,
-        )
-
-    async def _get_dnd_status(self) -> dict[str, AmazonDeviceSensor]:
-        dnd_status: dict[str, AmazonDeviceSensor] = {}
-        _, raw_resp = await self._http_wrapper.session_request(
-            method=HTTPMethod.GET,
-            url=f"https://alexa.amazon.{self._session_state_data.domain}{URI_DND}",
-        )
-
-        dnd_data = await self._http_wrapper.response_to_json(raw_resp, "dnd")
-
-        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
+        await self._sequence_handler.send_message(device, info_skill_name, "")
 
     async def _format_human_error(self, sensors_state: dict) -> bool:
         """Format human readable error from malformed data."""
@@ -847,3 +510,7 @@ class AmazonEchoApi:
         path = error[0].get("path", "Unknown path")
         _LOGGER.error("Error retrieving devices state: %s for path %s", msg, path)
         return True
+
+    async def set_do_not_disturb(self, device: AmazonDevice, enable: bool) -> None:
+        """Set Do Not Disturb status for a device."""
+        await self._dnd_handler.set_do_not_disturb(device, enable)

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

@@ -417,4 +417,13 @@ DEVICE_TYPE_TO_MODEL: dict[str, dict[str, str | None]] = {
         "model": "Ford SYNC 4",
         "hw_version": None,
     },
+    "A1J16TEDOYCZTN": {
+        "model": "Fire Tablet 7",
+        "hw_version": "Gen7",
+    },
+    "A18TCD9FP10WJ9": {
+        "manufacturer": "Netgear",
+        "model": "Orbi Voice (RBS40V)",
+        "hw_version": None,
+    },
 }

{aioamazondevices-9.0.3 → aioamazondevices-11.0.1}/src/aioamazondevices/const/http.py

@@ -30,7 +30,8 @@ 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_DND_STATUS_ALL = "/api/dnd/device-status-list"
+URI_DND_STATUS_DEVICE = "/api/dnd/status"
+URI_NEXUS_GRAPHQL = "/nexus/v1/graphql"
 URI_NOTIFICATIONS = "/api/notifications"
 URI_SIGNIN = "/ap/signin"
-URI_NEXUS_GRAPHQL = "/nexus/v1/graphql"

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

@@ -4,7 +4,7 @@ import asyncio
 import base64
 import secrets
 from collections.abc import Callable, Coroutine
-from http import HTTPStatus
+from http import HTTPMethod, HTTPStatus
 from http.cookies import Morsel
 from typing import Any, cast
 
@@ -23,13 +23,17 @@ from . import __version__
 from .const.http import (
     AMAZON_APP_BUNDLE_ID,
     AMAZON_APP_ID,
+    AMAZON_APP_NAME,
     AMAZON_APP_VERSION,
+    AMAZON_CLIENT_OS,
     AMAZON_DEVICE_SOFTWARE_VERSION,
     ARRAY_WRAPPER,
     CSRF_COOKIE,
     DEFAULT_HEADERS,
     HTTP_ERROR_199,
     HTTP_ERROR_299,
+    REFRESH_ACCESS_TOKEN,
+    REFRESH_AUTH_COOKIES,
     REQUEST_AGENT,
     URI_SIGNIN,
 )
@@ -214,13 +218,66 @@ class AmazonHttpWrapper:
 
         return HTTPStatus(error).phrase
 
+    async def refresh_data(self, data_type: str) -> tuple[bool, dict]:
+        """Refresh data."""
+        if not self._session_state_data.login_stored_data:
+            _LOGGER.debug("No login data available, cannot refresh")
+            return False, {}
+
+        data = {
+            "app_name": AMAZON_APP_NAME,
+            "app_version": AMAZON_APP_VERSION,
+            "di.sdk.version": "6.12.4",
+            "source_token": self._session_state_data.login_stored_data["refresh_token"],
+            "package_name": AMAZON_APP_BUNDLE_ID,
+            "di.hw.version": "iPhone",
+            "platform": "iOS",
+            "requested_token_type": data_type,
+            "source_token_type": "refresh_token",
+            "di.os.name": "iOS",
+            "di.os.version": AMAZON_CLIENT_OS,
+            "current_version": "6.12.4",
+            "previous_version": "6.12.4",
+            "domain": f"www.amazon.{self._session_state_data.domain}",
+        }
+
+        _, raw_resp = await self.session_request(
+            method=HTTPMethod.POST,
+            url="https://api.amazon.com/auth/token",
+            input_data=data,
+            json_data=False,
+        )
+        _LOGGER.debug(
+            "Refresh data response %s with payload %s",
+            raw_resp.status,
+            orjson.dumps(data),
+        )
+
+        if raw_resp.status != HTTPStatus.OK:
+            _LOGGER.debug("Failed to refresh data")
+            return False, {}
+
+        json_response = await self.response_to_json(raw_resp, data_type)
+
+        if data_type == REFRESH_ACCESS_TOKEN and (
+            new_token := json_response.get(REFRESH_ACCESS_TOKEN)
+        ):
+            self._session_state_data.login_stored_data[REFRESH_ACCESS_TOKEN] = new_token
+            return True, json_response
+
+        if data_type == REFRESH_AUTH_COOKIES:
+            return True, json_response
+
+        _LOGGER.debug("Unexpected refresh data response")
+        return False, {}
+
     async def session_request(
         self,
         method: str,
         url: str,
         input_data: dict[str, Any] | list[dict[str, Any]] | None = None,
         json_data: bool = False,
-        agent: str = "Amazon",
+        extended_headers: dict[str, str] | None = None,
     ) -> tuple[BeautifulSoup, ClientResponse]:
         """Return request response context data."""
         _LOGGER.debug(
@@ -232,11 +289,15 @@ class AmazonHttpWrapper:
         )
 
         headers = DEFAULT_HEADERS.copy()
-        headers.update({"User-Agent": REQUEST_AGENT[agent]})
+        headers.update({"User-Agent": REQUEST_AGENT["Browser"]})
         headers.update({"Accept-Language": self._session_state_data.language})
         headers.update({"x-amzn-client": "github.com/chemelli74/aioamazondevices"})
         headers.update({"x-amzn-build-version": __version__})
 
+        if extended_headers:
+            _LOGGER.debug("Adding to headers: %s", extended_headers)
+            headers.update(extended_headers)
+
         if self._csrf_cookie:
             csrf = {CSRF_COOKIE: self._csrf_cookie}
             _LOGGER.debug("Adding to headers: %s", csrf)

aioamazondevices-11.0.1/src/aioamazondevices/implementation/__init__.py

@@ -0,0 +1 @@
+"""aioamazondevices implementation package."""

aioamazondevices-11.0.1/src/aioamazondevices/implementation/dnd.py

@@ -0,0 +1,56 @@
+"""Module to handle Alexa do not disturb setting."""
+
+from http import HTTPMethod
+
+from aioamazondevices.const.http import URI_DND_STATUS_ALL, URI_DND_STATUS_DEVICE
+from aioamazondevices.http_wrapper import AmazonHttpWrapper, AmazonSessionStateData
+from aioamazondevices.structures import AmazonDevice, AmazonDeviceSensor
+
+
+class AmazonDnDHandler:
+    """Class to handle Alexa Do Not Disturb functionality."""
+
+    def __init__(
+        self,
+        http_wrapper: AmazonHttpWrapper,
+        session_state_data: AmazonSessionStateData,
+    ) -> None:
+        """Initialize AmazonDnDHandler class."""
+        self._domain = session_state_data.domain
+        self._http_wrapper = http_wrapper
+
+    async def get_do_not_disturb_status(self) -> dict[str, AmazonDeviceSensor]:
+        """Get do_not_disturb status for all devices."""
+        dnd_status: dict[str, AmazonDeviceSensor] = {}
+        _, raw_resp = await self._http_wrapper.session_request(
+            method=HTTPMethod.GET,
+            url=f"https://alexa.amazon.{self._domain}{URI_DND_STATUS_ALL}",
+        )
+
+        dnd_data = await self._http_wrapper.response_to_json(raw_resp, "dnd")
+
+        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
+
+    async def set_do_not_disturb(self, device: AmazonDevice, enable: bool) -> None:
+        """Set do_not_disturb flag."""
+        payload = {
+            "deviceSerialNumber": device.serial_number,
+            "deviceType": device.device_type,
+            "enabled": enable,
+        }
+        url = f"https://alexa.amazon.{self._domain}{URI_DND_STATUS_DEVICE}"
+        await self._http_wrapper.session_request(
+            method=HTTPMethod.PUT,
+            url=url,
+            input_data=payload,
+            json_data=True,
+        )

aioamazondevices-11.0.1/src/aioamazondevices/implementation/notification.py

@@ -0,0 +1,224 @@
+"""Module to handle Alexa notifications."""
+
+from datetime import datetime, timedelta
+from http import HTTPMethod
+from typing import Any
+
+from dateutil.parser import parse
+from dateutil.rrule import rrulestr
+
+from aioamazondevices.const.devices import DEVICE_TO_IGNORE
+from aioamazondevices.const.http import REQUEST_AGENT, URI_NOTIFICATIONS
+from aioamazondevices.const.schedules import (
+    COUNTRY_GROUPS,
+    NOTIFICATION_ALARM,
+    NOTIFICATION_MUSIC_ALARM,
+    NOTIFICATION_REMINDER,
+    NOTIFICATION_TIMER,
+    NOTIFICATIONS_SUPPORTED,
+    RECURRING_PATTERNS,
+    WEEKEND_EXCEPTIONS,
+)
+from aioamazondevices.exceptions import CannotRetrieveData
+from aioamazondevices.http_wrapper import AmazonHttpWrapper, AmazonSessionStateData
+from aioamazondevices.structures import AmazonSchedule
+from aioamazondevices.utils import _LOGGER
+
+
+class AmazonNotificationHandler:
+    """Class to handle Alexa notifications."""
+
+    def __init__(
+        self,
+        session_state_data: AmazonSessionStateData,
+        http_wrapper: AmazonHttpWrapper,
+    ) -> None:
+        """Initialize AmazonNotificationHandler class."""
+        self._session_state_data = session_state_data
+        self._http_wrapper = http_wrapper
+
+    async def get_notifications(self) -> dict[str, dict[str, AmazonSchedule]] | None:
+        """Get all notifications (alarms, timers, reminders)."""
+        final_notifications: dict[str, dict[str, AmazonSchedule]] = {}
+
+        try:
+            _, raw_resp = await self._http_wrapper.session_request(
+                HTTPMethod.GET,
+                url=f"https://alexa.amazon.{self._session_state_data.domain}{URI_NOTIFICATIONS}",
+                extended_headers={"User-Agent": REQUEST_AGENT["Browser"]},
+            )
+        except CannotRetrieveData:
+            _LOGGER.warning(
+                "Failed to obtain notification data.  Timers and alarms have not been updated"  # noqa: E501
+            )
+            return None
+
+        notifications = await self._http_wrapper.response_to_json(
+            raw_resp, "notifications"
+        )
+
+        for schedule in notifications["notifications"]:
+            schedule_type: str = schedule["type"]
+            schedule_device_type = schedule["deviceType"]
+            schedule_device_serial = schedule["deviceSerialNumber"]
+
+            if schedule_device_type in DEVICE_TO_IGNORE:
+                continue
+
+            if schedule_type not in NOTIFICATIONS_SUPPORTED:
+                _LOGGER.debug(
+                    "Unsupported schedule type %s for device %s",
+                    schedule_type,
+                    schedule_device_serial,
+                )
+                continue
+
+            if schedule_type == NOTIFICATION_MUSIC_ALARM:
+                # Structure is the same as standard Alarm
+                schedule_type = NOTIFICATION_ALARM
+                schedule["type"] = NOTIFICATION_ALARM
+            label_desc = schedule_type.lower() + "Label"
+            if (schedule_status := schedule["status"]) == "ON" and (
+                next_occurrence := await self._parse_next_occurrence(schedule)
+            ):
+                schedule_notification_list = final_notifications.get(
+                    schedule_device_serial, {}
+                )
+                schedule_notification_by_type = schedule_notification_list.get(
+                    schedule_type
+                )
+                # Replace if no existing notification
+                # or if existing.next_occurrence is None
+                # or if new next_occurrence is earlier
+                if (
+                    not schedule_notification_by_type
+                    or schedule_notification_by_type.next_occurrence is None
+                    or next_occurrence < schedule_notification_by_type.next_occurrence
+                ):
+                    final_notifications.update(
+                        {
+                            schedule_device_serial: {
+                                **schedule_notification_list
+                                | {
+                                    schedule_type: AmazonSchedule(
+                                        type=schedule_type,
+                                        status=schedule_status,
+                                        label=schedule[label_desc],
+                                        next_occurrence=next_occurrence,
+                                    ),
+                                }
+                            }
+                        }
+                    )
+
+        return final_notifications
+
+    async def _parse_next_occurrence(
+        self,
+        schedule: dict[str, Any],
+    ) -> datetime | None:
+        """Parse RFC5545 rule set for next iteration."""
+        # Local timezone
+        tzinfo = datetime.now().astimezone().tzinfo
+        # Current time
+        actual_time = datetime.now(tz=tzinfo)
+        # Reference start date
+        today_midnight = actual_time.replace(hour=0, minute=0, second=0, microsecond=0)
+        # Reference time (1 minute ago to avoid edge cases)
+        now_reference = actual_time - timedelta(minutes=1)
+
+        # Schedule data
+        original_date = schedule.get("originalDate")
+        original_time = schedule.get("originalTime")
+
+        recurring_rules: list[str] = []
+        if schedule.get("rRuleData"):
+            recurring_rules = schedule["rRuleData"]["recurrenceRules"]
+        if schedule.get("recurringPattern"):
+            recurring_rules.append(schedule["recurringPattern"])
+
+        # Recurring events
+        if recurring_rules:
+            next_candidates: list[datetime] = []
+            for recurring_rule in recurring_rules:
+                # Already in RFC5545 format
+                if "FREQ=" in recurring_rule:
+                    rule = await self._add_hours_minutes(recurring_rule, original_time)
+
+                    # Add date to candidates list
+                    next_candidates.append(
+                        rrulestr(rule, dtstart=today_midnight).after(
+                            now_reference, True
+                        ),
+                    )
+                    continue
+
+                if recurring_rule not in RECURRING_PATTERNS:
+                    _LOGGER.warning(
+                        "Unknown recurring rule <%s> for schedule type <%s>",
+                        recurring_rule,
+                        schedule["type"],
+                    )
+                    return None
+
+                # Adjust recurring rules for country specific weekend exceptions
+                recurring_pattern = RECURRING_PATTERNS.copy()
+                for group, countries in COUNTRY_GROUPS.items():
+                    if self._session_state_data.country_code in countries:
+                        recurring_pattern |= WEEKEND_EXCEPTIONS[group]
+                        break
+
+                rule = await self._add_hours_minutes(
+                    recurring_pattern[recurring_rule], original_time
+                )
+
+                # Add date to candidates list
+                next_candidates.append(
+                    rrulestr(rule, dtstart=today_midnight).after(now_reference, True),
+                )
+
+            return min(next_candidates) if next_candidates else None
+
+        # Single events
+        if schedule["type"] == NOTIFICATION_ALARM:
+            timestamp = parse(f"{original_date} {original_time}").replace(tzinfo=tzinfo)
+
+        elif schedule["type"] == NOTIFICATION_TIMER:
+            # API returns triggerTime in milliseconds since epoch
+            timestamp = datetime.fromtimestamp(
+                schedule["triggerTime"] / 1000, tz=tzinfo
+            )
+
+        elif schedule["type"] == NOTIFICATION_REMINDER:
+            # API returns alarmTime in milliseconds since epoch
+            timestamp = datetime.fromtimestamp(schedule["alarmTime"] / 1000, tz=tzinfo)
+
+        else:
+            _LOGGER.warning(("Unknown schedule type: %s"), schedule["type"])
+            return None
+
+        if timestamp > now_reference:
+            return timestamp
+
+        return None
+
+    async def _add_hours_minutes(
+        self,
+        recurring_rule: str,
+        original_time: str | None,
+    ) -> str:
+        """Add hours and minutes to a RFC5545 string."""
+        rule = recurring_rule.removesuffix(";")
+
+        if not original_time:
+            return rule
+
+        # Add missing BYHOUR, BYMINUTE if needed (Alarms only)
+        if "BYHOUR=" not in recurring_rule:
+            hour = int(original_time.split(":")[0])
+            rule += f";BYHOUR={hour}"
+        if "BYMINUTE=" not in recurring_rule:
+            minute = int(original_time.split(":")[1])
+            rule += f";BYMINUTE={minute}"
+
+        return rule

aioamazondevices-11.0.1/src/aioamazondevices/implementation/sequence.py

@@ -0,0 +1,159 @@
+"""Module to handle Alexa sequence operations."""
+
+from http import HTTPMethod
+from typing import Any
+
+import orjson
+
+from aioamazondevices.const.metadata import ALEXA_INFO_SKILLS
+from aioamazondevices.http_wrapper import AmazonHttpWrapper, AmazonSessionStateData
+from aioamazondevices.structures import (
+    AmazonDevice,
+    AmazonMusicSource,
+    AmazonSequenceType,
+)
+from aioamazondevices.utils import _LOGGER
+
+
+class AmazonSequenceHandler:
+    """Class to handle Alexa sequence operations."""
+
+    def __init__(
+        self,
+        http_wrapper: AmazonHttpWrapper,
+        session_state_data: AmazonSessionStateData,
+    ) -> None:
+        """Initialize AmazonSequenceHandler."""
+        self._http_wrapper = http_wrapper
+        self._session_state_data = session_state_data
+
+    async def send_message(
+        self,
+        device: AmazonDevice,
+        message_type: str,
+        message_body: str,
+        message_source: AmazonMusicSource | None = None,
+    ) -> None:
+        """Send message to specific device."""
+        if not self._session_state_data.login_stored_data:
+            _LOGGER.warning("No login data available, cannot send message")
+            return
+
+        base_payload = {
+            "deviceType": device.device_type,
+            "deviceSerialNumber": device.serial_number,
+            "locale": self._session_state_data.language,
+            "customerId": self._session_state_data.account_customer_id,
+        }
+
+        payload: dict[str, Any]
+        if message_type == AmazonSequenceType.Speak:
+            payload = {
+                **base_payload,
+                "textToSpeak": message_body,
+                "target": {
+                    "customerId": self._session_state_data.account_customer_id,
+                    "devices": [
+                        {
+                            "deviceSerialNumber": device.serial_number,
+                            "deviceTypeId": device.device_type,
+                        },
+                    ],
+                },
+                "skillId": "amzn1.ask.1p.saysomething",
+            }
+        elif message_type == AmazonSequenceType.Announcement:
+            playback_devices: list[dict[str, str | None]] = [
+                {
+                    "deviceSerialNumber": serial,
+                    "deviceTypeId": device.device_cluster_members[serial],
+                }
+                for serial in device.device_cluster_members
+            ]
+
+            payload = {
+                **base_payload,
+                "expireAfter": "PT5S",
+                "content": [
+                    {
+                        "locale": self._session_state_data.language,
+                        "display": {
+                            "title": "Home Assistant",
+                            "body": message_body,
+                        },
+                        "speak": {
+                            "type": "text",
+                            "value": message_body,
+                        },
+                    }
+                ],
+                "target": {
+                    "customerId": self._session_state_data.account_customer_id,
+                    "devices": playback_devices,
+                },
+                "skillId": "amzn1.ask.1p.routines.messaging",
+            }
+        elif message_type == AmazonSequenceType.Sound:
+            payload = {
+                **base_payload,
+                "soundStringId": message_body,
+                "skillId": "amzn1.ask.1p.sound",
+            }
+        elif message_type == AmazonSequenceType.Music:
+            payload = {
+                **base_payload,
+                "searchPhrase": message_body,
+                "sanitizedSearchPhrase": message_body,
+                "musicProviderId": message_source,
+            }
+        elif message_type == AmazonSequenceType.TextCommand:
+            payload = {
+                **base_payload,
+                "skillId": "amzn1.ask.1p.tellalexa",
+                "text": message_body,
+            }
+        elif message_type == AmazonSequenceType.LaunchSkill:
+            payload = {
+                **base_payload,
+                "targetDevice": {
+                    "deviceType": device.device_type,
+                    "deviceSerialNumber": device.serial_number,
+                },
+                "connectionRequest": {
+                    "uri": "connection://AMAZON.Launch/" + message_body,
+                },
+            }
+        elif message_type in ALEXA_INFO_SKILLS:
+            payload = {
+                **base_payload,
+            }
+        else:
+            raise ValueError(f"Message type <{message_type}> is not recognised")
+
+        sequence = {
+            "@type": "com.amazon.alexa.behaviors.model.Sequence",
+            "startNode": {
+                "@type": "com.amazon.alexa.behaviors.model.SerialNode",
+                "nodesToExecute": [
+                    {
+                        "@type": "com.amazon.alexa.behaviors.model.OpaquePayloadOperationNode",  # noqa: E501
+                        "type": message_type,
+                        "operationPayload": payload,
+                    },
+                ],
+            },
+        }
+
+        node_data = {
+            "behaviorId": "PREVIEW",
+            "sequenceJson": orjson.dumps(sequence).decode("utf-8"),
+            "status": "ENABLED",
+        }
+
+        _LOGGER.debug("Preview data payload: %s", node_data)
+        await self._http_wrapper.session_request(
+            method=HTTPMethod.POST,
+            url=f"https://alexa.amazon.{self._session_state_data.domain}/api/behaviors/preview",
+            input_data=node_data,
+            json_data=True,
+        )

{aioamazondevices-9.0.3 → aioamazondevices-11.0.1}/src/aioamazondevices/login.py

@@ -10,20 +10,17 @@ from http import HTTPMethod, HTTPStatus
 from typing import Any, cast
 from urllib.parse import parse_qs, urlencode
 
-import orjson
 from bs4 import BeautifulSoup, Tag
 from multidict import MultiDictProxy
 from yarl import URL
 
 from .const.http import (
-    AMAZON_APP_BUNDLE_ID,
     AMAZON_APP_NAME,
     AMAZON_APP_VERSION,
     AMAZON_CLIENT_OS,
     AMAZON_DEVICE_SOFTWARE_VERSION,
     AMAZON_DEVICE_TYPE,
     DEFAULT_SITE,
-    REFRESH_ACCESS_TOKEN,
     REFRESH_AUTH_COOKIES,
     URI_DEVICES,
     URI_SIGNIN,
@@ -362,7 +359,7 @@ class AmazonLogin:
 
     async def _refresh_auth_cookies(self) -> None:
         """Refresh cookies after domain swap."""
-        _, json_token_resp = await self._refresh_data(REFRESH_AUTH_COOKIES)
+        _, json_token_resp = await self._http_wrapper.refresh_data(REFRESH_AUTH_COOKIES)
 
         # Need to take cookies from response and create them as cookies
         website_cookies = self._session_state_data.login_stored_data[
@@ -394,59 +391,6 @@ class AmazonLogin:
             await self._http_wrapper.clear_csrf_cookie()
             await self._refresh_auth_cookies()
 
-    async def _refresh_data(self, data_type: str) -> tuple[bool, dict]:
-        """Refresh data."""
-        if not self._session_state_data.login_stored_data:
-            _LOGGER.debug("No login data available, cannot refresh")
-            return False, {}
-
-        data = {
-            "app_name": AMAZON_APP_NAME,
-            "app_version": AMAZON_APP_VERSION,
-            "di.sdk.version": "6.12.4",
-            "source_token": self._session_state_data.login_stored_data["refresh_token"],
-            "package_name": AMAZON_APP_BUNDLE_ID,
-            "di.hw.version": "iPhone",
-            "platform": "iOS",
-            "requested_token_type": data_type,
-            "source_token_type": "refresh_token",
-            "di.os.name": "iOS",
-            "di.os.version": AMAZON_CLIENT_OS,
-            "current_version": "6.12.4",
-            "previous_version": "6.12.4",
-            "domain": f"www.amazon.{self._session_state_data.domain}",
-        }
-
-        _, raw_resp = await self._http_wrapper.session_request(
-            method=HTTPMethod.POST,
-            url="https://api.amazon.com/auth/token",
-            input_data=data,
-            json_data=False,
-        )
-        _LOGGER.debug(
-            "Refresh data response %s with payload %s",
-            raw_resp.status,
-            orjson.dumps(data),
-        )
-
-        if raw_resp.status != HTTPStatus.OK:
-            _LOGGER.debug("Failed to refresh data")
-            return False, {}
-
-        json_response = await self._http_wrapper.response_to_json(raw_resp, data_type)
-
-        if data_type == REFRESH_ACCESS_TOKEN and (
-            new_token := json_response.get(REFRESH_ACCESS_TOKEN)
-        ):
-            self._session_state_data.login_stored_data[REFRESH_ACCESS_TOKEN] = new_token
-            return True, json_response
-
-        if data_type == REFRESH_AUTH_COOKIES:
-            return True, json_response
-
-        _LOGGER.debug("Unexpected refresh data response")
-        return False, {}
-
     async def obtain_account_customer_id(self) -> None:
         """Find account customer id."""
         for retry_count in range(MAX_CUSTOMER_ACCOUNT_RETRIES):

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

@@ -37,7 +37,7 @@ class AmazonDevice:
     device_type: str
     device_owner_customer_id: str
     household_device: bool
-    device_cluster_members: list[str]
+    device_cluster_members: dict[str, str | None]
     online: bool
     serial_number: str
     software_version: str