@camstack/addon-import-alexa 0.2.188 → 0.2.190

package/i18n/en.json

@@ -1,7 +1,4 @@
 {
-  "globalSettings.s_alexa-account.title": "Amazon Alexa account",
-  "globalSettings.s_alexa-account.description": "Alexa accounts are managed in the External systems → Brokers tab.",
-  "globalSettings.s_alexa-account.accountHelp.label": "Accounts are managed separately",
   "connection.s_alexa-account.title": "Amazon Alexa account",
   "connection.s_alexa-account.description": "Link an Amazon account via the unofficial Alexa client. Supply a captured cookie OR a refresh token. NOTE: this is an unofficial integration — Amazon can change or break it without notice, and it may violate Amazon ToS. State is polled, not pushed.",
   "connection.s_alexa-account.amazonDomain.label": "Amazon domain (region)",

package/i18n/it.json

@@ -1,7 +1,4 @@
 {
-  "globalSettings.s_alexa-account.title": "Account Amazon Alexa",
-  "globalSettings.s_alexa-account.description": "Gli account Alexa si gestiscono nella scheda Sistemi esterni → Broker.",
-  "globalSettings.s_alexa-account.accountHelp.label": "Gli account si gestiscono separatamente",
   "connection.s_alexa-account.title": "Account Amazon Alexa",
   "connection.s_alexa-account.description": "Collega un account Amazon tramite il client Alexa non ufficiale. Fornisci un cookie catturato OPPURE un refresh token. NOTA: è un'integrazione non ufficiale — Amazon può modificarla o interromperla senza preavviso, e potrebbe violare i termini di servizio Amazon. Lo stato viene interrogato, non inviato.",
   "connection.s_alexa-account.amazonDomain.label": "Dominio Amazon (regione)",

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@camstack/addon-import-alexa",
-  "version": "0.2.188",
+  "version": "0.2.190",
   "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",
@@ -35,7 +35,7 @@
     "addons": [
       {
         "id": "import-alexa",
-        "integrationRole": "both",
+        "integrationRole": "devices",
         "category": "providers",
         "name": "Alexa",
         "version": "0.1.0",
@@ -72,7 +72,7 @@
       }
     ],
     "requires": {
-      "server": ">=1.2.774"
+      "server": ">=1.2.780"
     }
   },
   "files": [

package/python/alexa_gateway.py

@@ -24,6 +24,21 @@ NP_COMMANDS = {
 }
 RATE_LIMITED = "rate-limited"
 
+# alexapy retries a 429 or a connection error by itself for 90-120 s per call and the
+# decorator takes no per-call limit. A command is not worth that: cancelling the call
+# from outside ends the retries, so the operator gets an answer while it still matters.
+COMMAND_TIMEOUT_S = 10.0
+
+
+async def run_command(call, what: str):
+    """Run one command coroutine, giving up after COMMAND_TIMEOUT_S (alexapy's retries are cancelled)."""
+    try:
+        return await asyncio.wait_for(call, timeout=COMMAND_TIMEOUT_S)
+    except asyncio.TimeoutError as err:
+        raise RuntimeError(
+            f"amazon did not accept {what} within {COMMAND_TIMEOUT_S:.0f} s (rate limit or connection retries)"
+        ) from err
+
 
 class RateLimitedError(Exception):
     """Amazon answered 429. It is a refusal to retry later, never an empty answer."""
@@ -267,7 +282,7 @@ class AlexaPyGateway:
         device_type = self._device_type_of(serial)
         async with self._lock(serial):
             try:
-                await self._api_for(serial, device_type).set_media({"type": body})
+                await run_command(self._api_for(serial, device_type).set_media({"type": body}), "the media command")
             except Exception as err:  # noqa: BLE001 — typed below
                 if is_rate_limited(err):
                     raise RateLimitedError("amazon rate limit (429) on a media command") from err
@@ -283,7 +298,7 @@ class AlexaPyGateway:
         _AlexaLogin, AlexaAPI = _import_alexapy()
         async with self._lock(serial):
             try:
-                await AlexaAPI(None, login).run_behavior(node, queue_delay=0)
+                await run_command(AlexaAPI(None, login).run_behavior(node, queue_delay=0), "the volume")
             except Exception as err:  # noqa: BLE001 — typed below
                 if is_rate_limited(err):
                     raise RateLimitedError("amazon rate limit (429) on the volume") from err

package/python/alexa_logging.py

@@ -0,0 +1,33 @@
+"""Worker logging. stderr only (stdout is the protocol); the hub scrubs and forwards it.
+
+alexapy retries a 429 or a connection error on its own and says so only through the
+`backoff` library's INFO lines. Those are the one alexapy record let through: its other
+records carry URLs and request arguments, so every other alexapy record stays out.
+"""
+
+from __future__ import annotations
+
+import logging
+import sys
+
+# `backoff` formats these as "Backing off _request(...) for 1.2s (Error)": the call's
+# arguments are elided, so a cookie or token cannot reach the line.
+BACKOFF_PREFIXES = ("Backing off ", "Giving up ")
+
+
+class AlexapyBackoffOnly(logging.Filter):
+    def filter(self, record: logging.LogRecord) -> bool:
+        if not record.name.startswith("alexapy"):
+            return record.levelno >= logging.WARNING
+        return record.getMessage().startswith(BACKOFF_PREFIXES)
+
+
+def configure_logging(stream=None) -> logging.Handler:
+    handler = logging.StreamHandler(stream if stream is not None else sys.stderr)
+    handler.setFormatter(logging.Formatter("%(name)s %(levelname)s %(message)s"))
+    handler.addFilter(AlexapyBackoffOnly())
+    root = logging.getLogger()
+    root.addHandler(handler)
+    root.setLevel(logging.WARNING)
+    logging.getLogger("alexapy").setLevel(logging.INFO)
+    return handler

package/python/alexa_worker.py

@@ -11,6 +11,8 @@ import json
 import sys
 import traceback
 
+from alexa_logging import configure_logging
+
 
 async def serve() -> None:
     # Imported here so `python -m unittest` of the protocol does not need alexapy.
@@ -43,6 +45,7 @@ async def serve() -> None:
 
 
 def main() -> None:
+    configure_logging()
     asyncio.run(serve())
 
 

package/python/test_alexa_command_limits.py

@@ -0,0 +1,80 @@
+"""A command fails fast instead of riding alexapy's 90-120 s retry; backoff lines reach stderr."""
+
+from __future__ import annotations
+
+import asyncio
+import io
+import logging
+import sys
+import unittest
+from pathlib import Path
+
+sys.path.insert(0, str(Path(__file__).resolve().parent))
+
+import alexa_gateway
+from alexa_logging import configure_logging
+from test_alexa_gateway_echo import install_fake
+
+
+class CommandTimeoutTests(unittest.TestCase):
+    def setUp(self) -> None:
+        self._saved = alexa_gateway.COMMAND_TIMEOUT_S
+        alexa_gateway.COMMAND_TIMEOUT_S = 0.05
+
+    def tearDown(self) -> None:
+        alexa_gateway.COMMAND_TIMEOUT_S = self._saved
+        sys.modules.pop("alexapy", None)
+
+    def _stall(self, gateway, name: str) -> None:
+        async def forever(*_a, **_k):
+            await asyncio.sleep(30)  # alexapy backing off a 429
+
+        import alexapy
+
+        setattr(alexapy.AlexaAPI, name, forever)
+
+    def test_set_volume_gives_up_instead_of_retrying_for_minutes(self) -> None:
+        gateway, _ = install_fake()
+        self._stall(gateway, "run_behavior")
+        with self.assertRaisesRegex(RuntimeError, "did not accept the volume"):
+            asyncio.run(gateway.set_volume("s1", 30))
+
+    def test_np_command_gives_up_too(self) -> None:
+        gateway, _ = install_fake()
+        self._stall(gateway, "set_media")
+        with self.assertRaisesRegex(RuntimeError, "did not accept the media command"):
+            asyncio.run(gateway.np_command("s1", "play"))
+
+    def test_a_stalled_command_releases_the_per_device_lock(self) -> None:
+        gateway, calls = install_fake()
+        self._stall(gateway, "run_behavior")
+
+        async def go():
+            with self.assertRaises(RuntimeError):
+                await gateway.set_volume("s1", 30)
+            await gateway.np_command("s1", "play")
+
+        asyncio.run(go())
+        self.assertEqual(len(calls["media"]), 1)
+
+
+class LoggingTests(unittest.TestCase):
+    def test_backoff_lines_pass_and_other_alexapy_records_do_not(self) -> None:
+        stream = io.StringIO()
+        handler = configure_logging(stream)
+        try:
+            log = logging.getLogger("alexapy.alexaapi")
+            log.info("Backing off _request(...) for 1.2s (AlexapyTooManyRequestsError: 429)")
+            log.info("cookie=SECRET csrf=SECRET")
+            log.warning("HTTP (URL: https://x/?token=SECRET) error status 500")
+            logging.getLogger("camstack.worker").warning("our own warning")
+        finally:
+            logging.getLogger().removeHandler(handler)
+        out = stream.getvalue()
+        self.assertIn("Backing off _request(...)", out)
+        self.assertIn("our own warning", out)
+        self.assertNotIn("SECRET", out)
+
+
+if __name__ == "__main__":
+    unittest.main()