aioamazondevices 6.4.5__py3-none-any.whl → 6.5.0__py3-none-any.whl

aioamazondevices/__init__.py

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

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
@@ -39,6 +41,7 @@ from .const import (
     AMAZON_DEVICE_SOFTWARE_VERSION,
     AMAZON_DEVICE_TYPE,
     BIN_EXTENSION,
+    COUNTRY_GROUPS,
     CSRF_COOKIE,
     DEFAULT_HEADERS,
     DEFAULT_SITE,
@@ -48,6 +51,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 +64,9 @@ from .const import (
     URI_DEVICES,
     URI_DND,
     URI_NEXUS_GRAPHQL,
+    URI_NOTIFICATIONS,
     URI_SIGNIN,
+    WEEKEND_EXCEPTIONS,
 )
 from .exceptions import (
     CannotAuthenticate,
@@ -81,6 +91,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 +118,7 @@ class AmazonDevice:
     entity_id: str | None
     endpoint_id: str | None
     sensors: dict[str, AmazonDeviceSensor]
+    notifications: dict[str, AmazonSchedule]
 
 
 class AmazonSequenceType(StrEnum):
@@ -173,6 +194,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)
@@ -766,6 +788,163 @@ class AmazonEchoApi:
         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(
@@ -943,8 +1122,13 @@ class AmazonEchoApi:
             await self._get_base_devices()
             self._last_devices_refresh = datetime.now(UTC)
 
+        # Only refresh endpoint data if we have no endpoints yet
         delta_endpoints = datetime.now(UTC) - self._last_endpoint_refresh
-        if delta_endpoints >= timedelta(minutes=30):
+        endpoint_refresh_needed = delta_endpoints >= timedelta(days=1)
+        endpoints_recently_checked = delta_endpoints < timedelta(minutes=30)
+        if (
+            not self._endpoints and not endpoints_recently_checked
+        ) or endpoint_refresh_needed:
             _LOGGER.debug(
                 "Refreshing endpoint data after %s",
                 str(timedelta(minutes=round(delta_endpoints.total_seconds() / 60))),
@@ -960,6 +1144,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, {})
@@ -971,7 +1156,28 @@ 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()
         for serial_number in self._final_devices:
             device_endpoint = devices_endpoints.get(serial_number, {})
@@ -1033,6 +1239,7 @@ class AmazonEchoApi:
                 entity_id=None,
                 endpoint_id=None,
                 sensors={},
+                notifications={},
             )
 
         self._list_for_clusters.update(

aioamazondevices/const.py

@@ -54,6 +54,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 +478,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.5.dist-info → aioamazondevices-6.5.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: aioamazondevices
-Version: 6.4.5
+Version: 6.5.0
 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.5.0.dist-info/RECORD

@@ -0,0 +1,12 @@
+aioamazondevices/__init__.py,sha256=T63aexWxTzW2X40gC-0WS_XqR-gWU7pV8ggK1C-xOPM,276
+aioamazondevices/api.py,sha256=5RY7f5mGCpIg3QUxD2ZhjhZ2UwR1IRuuT170aEp1X6U,58561
+aioamazondevices/const.py,sha256=DLjCgIEVBBezEAqlKHNA2KN9JjR-oxr3UCKG1WXdJqQ,13515
+aioamazondevices/exceptions.py,sha256=gRYrxNAJnrV6uRuMx5e76VMvtNKyceXd09q84pDBBrI,638
+aioamazondevices/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+aioamazondevices/query.py,sha256=SKn-fXFUnXnCvmKd6IvAGdkFL7sBzhYBEAZ0aZ2ez9E,1800
+aioamazondevices/sounds.py,sha256=CXMDk-KoKVFxBdVAw3MeOClqgpzcVDxvQhFOJp7qX-Y,1896
+aioamazondevices/utils.py,sha256=RzuKRhnq_8ymCoJMoQJ2vBYyuew06RSWpqQWmqdNczE,2019
+aioamazondevices-6.5.0.dist-info/METADATA,sha256=ehwDX3IxhNr57zmjOw4i4EiBP01bBblB64kfZG2iBwk,7679
+aioamazondevices-6.5.0.dist-info/WHEEL,sha256=zp0Cn7JsFoX2ATtOhtaFYIiE2rmFAD4OcMhtUki8W3U,88
+aioamazondevices-6.5.0.dist-info/licenses/LICENSE,sha256=sS48k5sp9bFV-NSHDfAJuTZZ_-AP9ZDqUzQ9sffGlsg,11346
+aioamazondevices-6.5.0.dist-info/RECORD,,

aioamazondevices-6.4.5.dist-info/RECORD

@@ -1,12 +0,0 @@
-aioamazondevices/__init__.py,sha256=OFf1p25xoL4BCdFQmpphXf541iLmm0Py8LC_rJYPL98,276
-aioamazondevices/api.py,sha256=uTWsZagMQDZ4I-v8lpk9xCTebxUTMDXMU6JE4NANhPc,50367
-aioamazondevices/const.py,sha256=BZTyUku94uQa50R1ZeXo1h585xgUNT_Pb7KAifjawWc,12266
-aioamazondevices/exceptions.py,sha256=gRYrxNAJnrV6uRuMx5e76VMvtNKyceXd09q84pDBBrI,638
-aioamazondevices/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-aioamazondevices/query.py,sha256=SKn-fXFUnXnCvmKd6IvAGdkFL7sBzhYBEAZ0aZ2ez9E,1800
-aioamazondevices/sounds.py,sha256=CXMDk-KoKVFxBdVAw3MeOClqgpzcVDxvQhFOJp7qX-Y,1896
-aioamazondevices/utils.py,sha256=RzuKRhnq_8ymCoJMoQJ2vBYyuew06RSWpqQWmqdNczE,2019
-aioamazondevices-6.4.5.dist-info/METADATA,sha256=k0QHRnM6juLj756-Okw0vq_8FVolrQR7SCF2FF7UdU8,7648
-aioamazondevices-6.4.5.dist-info/WHEEL,sha256=zp0Cn7JsFoX2ATtOhtaFYIiE2rmFAD4OcMhtUki8W3U,88
-aioamazondevices-6.4.5.dist-info/licenses/LICENSE,sha256=sS48k5sp9bFV-NSHDfAJuTZZ_-AP9ZDqUzQ9sffGlsg,11346
-aioamazondevices-6.4.5.dist-info/RECORD,,