aioamazondevices 6.4.6__tar.gz → 6.5.1__tar.gz

{aioamazondevices-6.4.6 → aioamazondevices-6.5.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: aioamazondevices
-Version: 6.4.6
+Version: 6.5.1
 Summary: Python library to control Amazon devices
 License-Expression: Apache-2.0
 License-File: LICENSE
@@ -17,6 +17,7 @@ Requires-Dist: beautifulsoup4
 Requires-Dist: colorlog
 Requires-Dist: langcodes
 Requires-Dist: orjson (>=3.10,<4)
+Requires-Dist: python-dateutil
 Project-URL: Bug Tracker, https://github.com/chemelli74/aioamazondevices/issues
 Project-URL: Changelog, https://github.com/chemelli74/aioamazondevices/blob/main/CHANGELOG.md
 Project-URL: Homepage, https://github.com/chemelli74/aioamazondevices

{aioamazondevices-6.4.6 → aioamazondevices-6.5.1}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "aioamazondevices"
-version = "6.4.6"
+version = "6.5.1"
 requires-python = ">=3.12"
 description = "Python library to control Amazon devices"
 authors = [
@@ -25,6 +25,7 @@ dependencies = [
 "colorlog",
 "langcodes",
 "orjson (>=3.10,<4)",
+"python-dateutil",
 ]
 
 [project.urls]
@@ -35,6 +36,7 @@ dependencies = [
 [tool.poetry.group.dev.dependencies]
 pytest = "^8.4"
 pytest-cov = ">=5,<8"
+types-python-dateutil = "^2.9.0.20250822"
 
 [tool.semantic_release]
 version_toml = ["pyproject.toml:project.version"]

{aioamazondevices-6.4.6 → aioamazondevices-6.5.1}/src/aioamazondevices/__init__.py

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

{aioamazondevices-6.4.6 → aioamazondevices-6.5.1}/src/aioamazondevices/api.py

@@ -23,6 +23,8 @@ from aiohttp import (
     ContentTypeError,
 )
 from bs4 import BeautifulSoup, Tag
+from dateutil.parser import parse
+from dateutil.rrule import rrulestr
 from langcodes import Language, standardize_tag
 from multidict import MultiDictProxy
 from yarl import URL
@@ -38,7 +40,9 @@ from .const import (
     AMAZON_CLIENT_OS,
     AMAZON_DEVICE_SOFTWARE_VERSION,
     AMAZON_DEVICE_TYPE,
+    ARRAY_WRAPPER,
     BIN_EXTENSION,
+    COUNTRY_GROUPS,
     CSRF_COOKIE,
     DEFAULT_HEADERS,
     DEFAULT_SITE,
@@ -48,6 +52,11 @@ from .const import (
     HTTP_ERROR_199,
     HTTP_ERROR_299,
     JSON_EXTENSION,
+    NOTIFICATION_ALARM,
+    NOTIFICATION_MUSIC_ALARM,
+    NOTIFICATION_REMINDER,
+    NOTIFICATION_TIMER,
+    RECURRING_PATTERNS,
     REFRESH_ACCESS_TOKEN,
     REFRESH_AUTH_COOKIES,
     REQUEST_AGENT,
@@ -56,7 +65,9 @@ from .const import (
     URI_DEVICES,
     URI_DND,
     URI_NEXUS_GRAPHQL,
+    URI_NOTIFICATIONS,
     URI_SIGNIN,
+    WEEKEND_EXCEPTIONS,
 )
 from .exceptions import (
     CannotAuthenticate,
@@ -81,6 +92,16 @@ class AmazonDeviceSensor:
     scale: str | None
 
 
+@dataclass
+class AmazonSchedule:
+    """Amazon schedule class."""
+
+    type: str  # alarm, reminder, timer
+    status: str
+    label: str
+    next_occurrence: datetime | None
+
+
 @dataclass
 class AmazonDevice:
     """Amazon device class."""
@@ -98,6 +119,7 @@ class AmazonDevice:
     entity_id: str | None
     endpoint_id: str | None
     sensors: dict[str, AmazonDeviceSensor]
+    notifications: dict[str, AmazonSchedule]
 
 
 class AmazonSequenceType(StrEnum):
@@ -173,6 +195,7 @@ class AmazonEchoApi:
         lang_object = Language.make(territory=country_code.upper())
         lang_maximized = lang_object.maximize()
 
+        self._country_code: str = country_code
         self._domain: str = domain
         language = f"{lang_maximized.language}-{lang_maximized.territory}"
         self._language = standardize_tag(language)
@@ -584,20 +607,19 @@ class AmazonEchoApi:
         _LOGGER.info("Register device: %s", scrub_fields(login_data))
         return login_data
 
-    async def _get_sensors_state(
-        self, endpoint_id_list: list[str]
-    ) -> dict[str, Any] | list[dict[str, Any]]:
-        """Get sensor State."""
+    async def _get_sensors_states(self) -> dict[str, dict[str, AmazonDeviceSensor]]:
+        """Retrieve devices sensors states."""
+        devices_sensors: dict[str, dict[str, AmazonDeviceSensor]] = {}
+
+        endpoint_ids = list(self._endpoints.keys())
         payload = [
             {
                 "operationName": "getEndpointState",
                 "variables": {
-                    "endpointId": endpoint_id,
-                    "latencyTolerance": "LOW",
+                    "endpointIds": endpoint_ids,
                 },
                 "query": QUERY_SENSOR_STATE,
             }
-            for endpoint_id in endpoint_id_list
         ]
 
         _, raw_resp = await self._session_request(
@@ -607,47 +629,29 @@ class AmazonEchoApi:
             json_data=True,
         )
 
-        return await self._response_to_json(raw_resp)
+        sensors_state = await self._response_to_json(raw_resp)
+        _LOGGER.debug("Sensor data - %s", sensors_state)
 
-    async def _get_sensors_states(self) -> dict[str, dict[str, AmazonDeviceSensor]]:
-        """Retrieve devices sensors states."""
-        devices_sensors: dict[str, dict[str, AmazonDeviceSensor]] = {}
-
-        # 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 await self._format_human_error(sensors_state):
+            # Explicit error in returned data
+            return {}
 
-            if not isinstance(sensors_state, list) and (
-                error := sensors_state.get("errors")
-            ):
-                if isinstance(error, list):
-                    error = error[0]
-                msg = error.get("message", "Unknown error")
-                path = error.get("path", "Unknown path")
-                _LOGGER.error(
-                    "Error retrieving devices state: %s for path %s", msg, path
-                )
-                return {}
+        if (
+            not (arr := sensors_state.get(ARRAY_WRAPPER))
+            or not (data := arr[0].get("data"))
+            or not (endpoints_list := data.get("listEndpoints"))
+            or not (endpoints := endpoints_list.get("endpoints"))
+        ):
+            _LOGGER.error("Malformed sensor state data received: %s", sensors_state)
+            return {}
 
-            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")]
+        for endpoint in endpoints:
+            serial_number = self._endpoints[endpoint.get("endpointId")]
 
-                if serial_number in self._final_devices:
-                    devices_sensors[serial_number] = self._get_device_sensor_state(
-                        endpoint, serial_number
-                    )
+            if serial_number in self._final_devices:
+                devices_sensors[serial_number] = self._get_device_sensor_state(
+                    endpoint, serial_number
+                )
 
         return devices_sensors
 
@@ -736,7 +740,7 @@ class AmazonEchoApi:
         endpoint_data = await self._response_to_json(raw_resp)
 
         if not (data := endpoint_data.get("data")) or not data.get("listEndpoints"):
-            _LOGGER.error("Malformed endpoint data received: %s", endpoint_data)
+            await self._format_human_error(endpoint_data)
             return {}
 
         endpoints = data["listEndpoints"]
@@ -760,12 +764,173 @@ class AmazonEchoApi:
             if not data:
                 _LOGGER.warning("Empty JSON data received")
                 data = {}
+            if isinstance(data, list):
+                # if anonymous array is returned wrap it inside
+                # generated key to convert list to dict
+                data = {ARRAY_WRAPPER: data}
             return cast("dict[str, Any]", data)
         except ContentTypeError as exc:
             raise ValueError("Response not in JSON format") from exc
         except orjson.JSONDecodeError as exc:
             raise ValueError("Response with corrupted JSON format") from exc
 
+    async def _get_notifications(self) -> dict[str, dict[str, AmazonSchedule]]:
+        final_notifications: dict[str, dict[str, AmazonSchedule]] = {}
+
+        _, raw_resp = await self._session_request(
+            HTTPMethod.GET,
+            url=f"https://alexa.amazon.{self._domain}{URI_NOTIFICATIONS}",
+        )
+        notifications = await self._response_to_json(raw_resp)
+        for schedule in notifications["notifications"]:
+            schedule_type: str = schedule["type"]
+            schedule_device_serial = schedule["deviceSerialNumber"]
+            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", recurring_rule)
+                    return None
+
+                # Adjust recurring rules for country specific weekend exceptions
+                recurring_pattern = RECURRING_PATTERNS.copy()
+                for group, countries in COUNTRY_GROUPS.items():
+                    if self._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 login_mode_interactive(self, otp_code: str) -> dict[str, Any]:
         """Login to Amazon interactively via OTP."""
         _LOGGER.debug(
@@ -965,6 +1130,7 @@ 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()
         for device in self._final_devices.values():
             # Update sensors
             sensors = devices_sensors.get(device.serial_number, {})
@@ -976,6 +1142,26 @@ class AmazonEchoApi:
             if device_dnd := dnd_sensors.get(device.serial_number):
                 device.sensors["dnd"] = device_dnd
 
+            # Update notifications
+            device_notifications = notifications.get(device.serial_number, {})
+
+            # Add only supported notification types
+            for capability, notification_type in [
+                ("REMINDERS", NOTIFICATION_REMINDER),
+                ("TIMERS_AND_ALARMS", NOTIFICATION_ALARM),
+                ("TIMERS_AND_ALARMS", NOTIFICATION_TIMER),
+            ]:
+                if (
+                    capability in device.capabilities
+                    and notification_type in device_notifications
+                    and (
+                        notification_object := device_notifications.get(
+                            notification_type
+                        )
+                    )
+                ):
+                    device.notifications[notification_type] = notification_object
+
     async def _set_device_endpoints_data(self) -> None:
         """Set device endpoint data."""
         devices_endpoints = await self._get_devices_endpoint_data()
@@ -1039,6 +1225,7 @@ class AmazonEchoApi:
                 entity_id=None,
                 endpoint_id=None,
                 sensors={},
+                notifications={},
             )
 
         self._list_for_clusters.update(
@@ -1375,3 +1562,18 @@ class AmazonEchoApi:
                 scale=None,
             )
         return dnd_status
+
+    async def _format_human_error(self, sensors_state: dict) -> bool:
+        """Format human readable error from malformed data."""
+        if sensors_state.get(ARRAY_WRAPPER):
+            error = sensors_state[ARRAY_WRAPPER][0].get("errors", [])
+        else:
+            error = sensors_state.get("errors", [])
+
+        if not error:
+            return False
+
+        msg = error[0].get("message", "Unknown error")
+        path = error[0].get("path", "Unknown path")
+        _LOGGER.error("Error retrieving devices state: %s for path %s", msg, path)
+        return True

{aioamazondevices-6.4.6 → aioamazondevices-6.5.1}/src/aioamazondevices/const.py

@@ -4,6 +4,8 @@ import logging
 
 _LOGGER = logging.getLogger(__package__)
 
+ARRAY_WRAPPER = "generatedArrayWrapper"
+
 HTTP_ERROR_199 = 199
 HTTP_ERROR_299 = 299
 
@@ -54,6 +56,7 @@ REFRESH_AUTH_COOKIES = "auth_cookies"
 
 URI_DEVICES = "/api/devices-v2/device"
 URI_DND = "/api/dnd/device-status-list"
+URI_NOTIFICATIONS = "/api/notifications"
 URI_SIGNIN = "/ap/signin"
 URI_NEXUS_GRAPHQL = "/nexus/v1/graphql"
 
@@ -477,3 +480,57 @@ DEVICE_TYPE_TO_MODEL: dict[str, dict[str, str | None]] = {
         "hw_version": "Gen2",
     },
 }
+
+RECURRING_PATTERNS: dict[str, str] = {
+    "XXXX-WD": "FREQ=WEEKLY;BYDAY=MO,TU,WE,TH,FR",
+    "XXXX-WE": "FREQ=WEEKLY;BYDAY=SA,SU",
+    "XXXX-WXX-1": "FREQ=WEEKLY;BYDAY=MO",
+    "XXXX-WXX-2": "FREQ=WEEKLY;BYDAY=TU",
+    "XXXX-WXX-3": "FREQ=WEEKLY;BYDAY=WE",
+    "XXXX-WXX-4": "FREQ=WEEKLY;BYDAY=TH",
+    "XXXX-WXX-5": "FREQ=WEEKLY;BYDAY=FR",
+    "XXXX-WXX-6": "FREQ=WEEKLY;BYDAY=SA",
+    "XXXX-WXX-7": "FREQ=WEEKLY;BYDAY=SU",
+}
+
+WEEKEND_EXCEPTIONS = {
+    "TH-FR": {
+        "XXXX-WD": "FREQ=WEEKLY;BYDAY=MO,TU,WE,SA,SU",
+        "XXXX-WE": "FREQ=WEEKLY;BYDAY=TH,FR",
+    },
+    "FR-SA": {
+        "XXXX-WD": "FREQ=WEEKLY;BYDAY=MO,TU,WE,TH,SU",
+        "XXXX-WE": "FREQ=WEEKLY;BYDAY=FR,SA",
+    },
+}
+
+# Countries grouped by their weekend type
+COUNTRY_GROUPS = {
+    "TH-FR": ["IR"],
+    "FR-SA": [
+        "AF",
+        "BD",
+        "BH",
+        "DZ",
+        "EG",
+        "IL",
+        "IQ",
+        "JO",
+        "KW",
+        "LY",
+        "MV",
+        "MY",
+        "OM",
+        "PS",
+        "QA",
+        "SA",
+        "SD",
+        "SY",
+        "YE",
+    ],
+}
+
+NOTIFICATION_ALARM = "Alarm"
+NOTIFICATION_MUSIC_ALARM = "MusicAlarm"
+NOTIFICATION_REMINDER = "Reminder"
+NOTIFICATION_TIMER = "Timer"

{aioamazondevices-6.4.6 → aioamazondevices-6.5.1}/src/aioamazondevices/query.py

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