@camstack/addon-import-alexa 0.2.175 → 0.2.177

package/i18n/en.json

@@ -14,7 +14,6 @@
   "echoTarget.s_echo.title": "Echo",
   "echoTarget.s_echo.brokerId.label": "Amazon account",
   "echoTarget.s_echo.echoId.label": "Echo",
-  "echoTarget.s_echo.volume.label": "Volume",
   "echoTarget.s_echo.respectDnd.label": "Respect Do Not Disturb",
   "globalSettings": {
     "s_alexa-proxy-login": {

package/i18n/it.json

@@ -14,7 +14,6 @@
   "echoTarget.s_echo.title": "Echo",
   "echoTarget.s_echo.brokerId.label": "Account Amazon",
   "echoTarget.s_echo.echoId.label": "Echo",
-  "echoTarget.s_echo.volume.label": "Volume",
   "echoTarget.s_echo.respectDnd.label": "Rispetta Non disturbare",
   "globalSettings": {
     "s_alexa-proxy-login": {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@camstack/addon-import-alexa",
-  "version": "0.2.175",
+  "version": "0.2.177",
   "description": "Alexa device-import provider for CamStack — imports the smart-home devices in a user's Alexa account via the unofficial alexa-remote2 cookie/token client (the inverse of the Alexa exporter)",
   "keywords": [
     "camstack",
@@ -68,7 +68,7 @@
       }
     ],
     "requires": {
-      "server": ">=1.2.723"
+      "server": ">=1.2.730"
     }
   },
   "files": [

package/python/alexa_gateway.py

@@ -69,6 +69,9 @@ def normalize_device(raw: dict) -> dict | None:
     return result
 
 
+# The skill alexapy itself names for an AlexaAnnouncement node.
+ANNOUNCEMENT_SKILL_ID = "amzn1.ask.1p.routines.messaging"
+
 class AlexaPyGateway:
     """Holds one AlexaLogin for the life of the process (one process per broker)."""
 
@@ -177,13 +180,28 @@ class AlexaPyGateway:
     async def speak(self, sequence: dict, customer_id: str) -> None:
         login = self._require_login()
         _AlexaLogin, AlexaAPI = _import_alexapy()
-        await AlexaAPI.send_sequence(login, sequence, customer_id, None)
+        # alexapy 1.29.20: send_sequence/send_announcement are INSTANCE methods that read the
+        # device behind the API object (type, serial, locale). Our payloads already carry the
+        # target, so run the prebuilt node through run_behavior, which needs only the login.
+        # queue_delay=0 posts at once instead of batching with other queued nodes.
+        await AlexaAPI(None, login).run_behavior(sequence["startNode"], queue_delay=0)
         self._touch_success()
 
     async def announce(self, announcement: dict, customer_id: str) -> None:
         login = self._require_login()
         _AlexaLogin, AlexaAPI = _import_alexapy()
-        await AlexaAPI.send_announcement(login, announcement, customer_id, None)
+        node = {
+            "@type": "com.amazon.alexa.behaviors.model.OpaquePayloadOperationNode",
+            "type": "AlexaAnnouncement",
+            "operationPayload": {
+                "expireAfter": announcement["expireAfter"],
+                "content": announcement["content"],
+                "target": announcement["target"],
+                "customerId": customer_id,
+                "skillId": ANNOUNCEMENT_SKILL_ID,
+            },
+        }
+        await AlexaAPI(None, login).run_behavior(node, queue_delay=0)
         self._touch_success()
 
     async def session_status(self) -> dict:

package/python/alexa_protocol.py

@@ -89,9 +89,6 @@ class Session:
         text = message.get("text")
         if not isinstance(text, str) or text == "":
             raise ValueError("text required")
-        volume = message.get("volume")
-        if not isinstance(volume, int):
-            volume = 40
         locale = REGION_LOCALE.get(self._gateway.region, "en-GB")
         outcomes: list[dict] = []
         for serial in targets:
@@ -104,7 +101,7 @@ class Session:
                 continue
             try:
                 if op == "speak":
-                    sequence = build_speak_sequence(target, text, volume, locale)
+                    sequence = build_speak_sequence(target, text, locale)
                     await self._gateway.speak(sequence, target["customerId"])
                 else:
                     announcement = build_announcement(target, text, locale)

package/python/alexa_sequences.py

@@ -29,27 +29,12 @@ def _speak_node(target: EchoTarget, text: str, locale: str) -> dict:
     }
 
 
-def _volume_node(target: EchoTarget, volume: int, nxt: dict) -> dict:
-    return {
-        "@type": "com.amazon.alexa.behaviors.model.OpaquePayloadOperationNode",
-        "type": "Alexa.DeviceControls.Volume",
-        "operationPayload": {
-            "deviceType": target["deviceType"],
-            "deviceSerialNumber": target["id"],
-            "customerId": target["customerId"],
-            "value": volume,
-        },
-        "next": nxt,
-    }
-
-
-def build_speak_sequence(target: EchoTarget, text: str, volume: int, locale: str) -> dict:
-    """Volume, then speech. Speak honours Do Not Disturb on the device."""
+def build_speak_sequence(target: EchoTarget, text: str, locale: str) -> dict:
+    """Speech at the Echo's current volume. Speak honours Do Not Disturb on the device."""
     speak = _speak_node(target, text, locale)
-    start = _volume_node(target, volume, speak) if volume >= 0 else speak
     return {
         "@type": "com.amazon.alexa.behaviors.model.Sequence",
-        "startNode": start,
+        "startNode": speak,
     }
 
 

package/python/test_alexa_gateway_send.py

@@ -0,0 +1,83 @@
+"""speak/announce must call alexapy the way alexapy 1.29.20 defines it.
+
+In that release send_sequence / send_announcement are INSTANCE methods that read
+`self._device`; calling them on the class with a login first (the old code) fails
+with "'AlexaLogin' object has no attribute '_device'". The fake below mirrors the
+real signatures, so the wrong call shape raises the same way.
+"""
+
+from __future__ import annotations
+
+import asyncio
+import sys
+import unittest
+from pathlib import Path
+
+sys.path.insert(0, str(Path(__file__).resolve().parent))
+
+from alexa_gateway import AlexaPyGateway
+from alexa_sequences import build_announcement, build_speak_sequence
+
+TARGET = {"id": "G090XX", "deviceType": "A3S5BH2HU6VAYF", "customerId": "A1CUST"}
+
+
+def make_fake_api(posted: list):
+    class FakeAlexaAPI:
+        def __init__(self, device, login):
+            self._device = device
+            self._login = login
+
+        async def run_behavior(self, node_data, queue_delay: float = 1.5) -> None:
+            posted.append((node_data, queue_delay))
+
+        # Real signatures: the first positional parameter is `self`, then message/sequence.
+        async def send_sequence(self, sequence, customer_id=None, queue_delay=1.5, extra=None, **kwargs):
+            self._device._device_type  # raises AttributeError without a device, as the real one
+
+        async def send_announcement(self, message, method="all", title="Announcement",
+                                    customer_id=None, targets=None, queue_delay=1.5, extra=None):
+            self._device._locale
+
+    return FakeAlexaAPI
+
+
+class SendTests(unittest.TestCase):
+    def _gateway(self, posted):
+        import types
+
+        package = types.ModuleType("alexapy")
+        package.AlexaLogin = object
+        package.AlexaAPI = make_fake_api(posted)
+        sys.modules["alexapy"] = package
+        sys.modules["alexapy.alexalogin"] = types.ModuleType("alexapy.alexalogin")
+        gateway = AlexaPyGateway()
+        gateway._login = object()
+        return gateway
+
+    def tearDown(self):
+        sys.modules.pop("alexapy", None)
+        sys.modules.pop("alexapy.alexalogin", None)
+
+    def test_speak_posts_the_sequence_start_node_immediately(self):
+        posted: list = []
+        sequence = build_speak_sequence(TARGET, "hello", 30, "it-IT")
+        asyncio.run(self._gateway(posted).speak(sequence, "A1CUST"))
+        self.assertEqual(posted, [(sequence["startNode"], 0)])
+
+    def test_announce_posts_an_announcement_node_with_target_and_content(self):
+        posted: list = []
+        announcement = build_announcement(TARGET, "hello", "it-IT")
+        asyncio.run(self._gateway(posted).announce(announcement, "A1CUST"))
+        self.assertEqual(len(posted), 1)
+        node, delay = posted[0]
+        self.assertEqual(delay, 0)
+        self.assertEqual(node["type"], "AlexaAnnouncement")
+        payload = node["operationPayload"]
+        self.assertEqual(payload["target"], announcement["target"])
+        self.assertEqual(payload["content"], announcement["content"])
+        self.assertEqual(payload["customerId"], "A1CUST")
+        self.assertEqual(payload["skillId"], "amzn1.ask.1p.routines.messaging")
+
+
+if __name__ == "__main__":
+    unittest.main()

package/python/test_alexa_protocol.py

@@ -136,19 +136,20 @@ class ProtocolTests(unittest.TestCase):
         session = Session(gateway)
         spoken = run(
             session,
-            {"id": "4", "op": "speak", "targets": ["echo-1"], "text": "Person at the door", "volume": 30},
+            {"id": "4", "op": "speak", "targets": ["echo-1"], "text": "Person at the door"},
         )
         self.assertTrue(spoken["result"]["outcomes"][0]["ok"])
         sequence = gateway.spoken[0]["sequence"]
-        self.assertEqual(sequence["startNode"]["type"], "Alexa.DeviceControls.Volume")
-        self.assertEqual(sequence["startNode"]["next"]["type"], "Alexa.Speak")
+        # No volume node: the Echo speaks at its current volume.
+        self.assertEqual(sequence["startNode"]["type"], "Alexa.Speak")
+        self.assertNotIn("next", sequence["startNode"])
         self.assertEqual(
-            sequence["startNode"]["next"]["operationPayload"]["textToSpeak"],
+            sequence["startNode"]["operationPayload"]["textToSpeak"],
             "Person at the door",
         )
         announced = run(
             session,
-            {"id": "5", "op": "announce", "targets": ["echo-1"], "text": "Hello", "volume": 30},
+            {"id": "5", "op": "announce", "targets": ["echo-1"], "text": "Hello"},
         )
         self.assertTrue(announced["result"]["outcomes"][0]["ok"])
         self.assertEqual(gateway.announced[0]["content"][0]["speak"]["value"], "Hello")
@@ -167,7 +168,7 @@ class ProtocolTests(unittest.TestCase):
 
     def test_sequence_helpers_do_not_embed_markup(self) -> None:
         target = {"id": "echo-1", "deviceType": "T", "customerId": "c"}
-        sequence = build_speak_sequence(target, "plain", 10, "en-GB")
+        sequence = build_speak_sequence(target, "plain", "en-GB")
         self.assertNotIn("<", json.dumps(sequence))
         announcement = build_announcement(target, "plain", "en-GB")
         self.assertEqual(announcement["content"][0]["speak"]["type"], "text")