Merge pull request #34 from rlippmann/master

1.1.3

Author: rlippmann

CHANGELOG.md

@@ -1,3 +1,11 @@
+## 1.1.3 (2023-10-11)
+
+* revert sync check logic to check against last check value.  this should hopefully fix the problem of HA alarm status not updating
+* use exponential backoff for gateway updates if offline instead of constant 90 seconds
+* add jitter to relogin interval
+* add quick_relogin/async_quick_relogin to do a quick relogin without requerying devices, exiting tasks
+* add more alarm testing in example client
+
 ## 1.1.2 (2023-10-06)
 
 * change default poll interval to 2 seconds

example-client.py

@@ -321,9 +321,9 @@ def test_alarm(site: ADTPulseSite, adt: PyADTPulse) -> None:
         check_updates(site, adt, True)
         print("Testing disarming twice")
         if site.disarm():
-            print("Test disarm twice failed")
+            print("Test disarm twice suceeded")
         else:
-            print("Test succeeded")
+            print("Test disarm twice failed")
     else:
         print("Disarming failed")
 
@@ -445,16 +445,33 @@ async def async_test_alarm(adt: PyADTPulse) -> None:
     """
     print("Arming alarm stay")
     if await adt.site.async_arm_home():
-        print("Alarm arming home succeeded")
-        #        check_updates(site, adt, False)
+        print("Arming stay call succeeded")
+        if adt.site.alarm_control_panel.is_arming:
+            print("Arming stay pending check succeeded")
+        else:
+            print(
+                f"FAIL: Arming home pending check failed {adt.site.alarm_control_panel} "
+            )
+        await adt.wait_for_update()
+        if adt.site.alarm_control_panel.is_home:
+            print("Arm stay no longer pending")
+        else:
+            while not adt.site.alarm_control_panel.is_home:
+                pprint(f"FAIL: Arm stay value incorrect {adt.site.alarm_control_panel}")
+                await adt.wait_for_update()
+
         print("Testing invalid alarm state change from armed home to armed away")
         if await adt.site.async_arm_away():
-            print("Error, armed away while already armed")
+            print(
+                f"FAIL: armed away while already armed {adt.site.alarm_control_panel}"
+            )
         else:
             print("Test succeeded")
             print("Testing changing alarm status to same value")
             if await adt.site.async_arm_home():
-                print("Error, allowed arming to same state")
+                print(
+                    f"FAIL: allowed arming to same state {adt.site.alarm_control_panel}"
+                )
             else:
                 print("Test succeeded")
 
@@ -463,35 +480,70 @@ async def async_test_alarm(adt: PyADTPulse) -> None:
         if await adt.site.async_arm_home(True):
             print("Force arm succeeded")
         else:
-            print("Force arm failed")
-
-    print()
-    print_site(adt.site)
-
+            print(f"FAIL: Force arm failed {adt.site.alarm_control_panel}")
     print("Disarming alarm")
     if await adt.site.async_disarm():
         print("Disarming succeeded")
-        #        check_updates(site, adt, False)
+        if adt.site.alarm_control_panel.is_disarming:
+            print("Disarm pending success")
+        else:
+            pprint(f"FAIL: Disarm pending fail {adt.site.alarm_control_panel}")
+        await adt.wait_for_update()
+        if adt.site.alarm_control_panel.is_disarmed:
+            print("Success update to disarm")
+        else:
+            while not adt.site.alarm_control_panel.is_disarmed:
+                pprint(
+                    "FAIL: did not set to disarm after update "
+                    f"{adt.site.alarm_control_panel}"
+                )
+                await adt.wait_for_update()
+            print("Test finally succeeded")
         print("Testing disarming twice")
         if await adt.site.async_disarm():
-            print("Test failed")
+            print("Double disarm call succeeded")
         else:
-            print("Test succeeded")
+            pprint(f"FAIL: Double disarm call failed {adt.site.alarm_control_panel}")
+        if adt.site.alarm_control_panel.is_disarming:
+            print("Double disarm state is disarming")
+        else:
+            pprint(
+                "FAIL: Double disarm state is not disarming "
+                f"{adt.site.alarm_control_panel}"
+            )
+        await adt.wait_for_update()
+        if adt.site.alarm_control_panel.is_disarmed:
+            print("Double disarm success")
+        else:
+            while not adt.site.alarm_control_panel.is_disarmed:
+                pprint(
+                    "FAIL: Double disarm state is not disarmed "
+                    f"{adt.site.alarm_control_panel}"
+                )
+                await adt.wait_for_update()
+            print("Test finally succeeded")
     else:
         print("Disarming failed")
-
-    print()
-    print_site(adt.site)
     print("Arming alarm away")
-
     if await adt.site.async_arm_away():
-        print("Arm away succeeded")
-    #        check_updates(site, adt, False)
+        print("Arm away call succeeded")
+        if adt.site.alarm_control_panel.is_arming:
+            print("Arm away arm pending")
+        else:
+            pprint(f"FAIL: arm away call not pending {adt.site.alarm_control_panel}")
+        await adt.wait_for_update()
+        if adt.site.alarm_control_panel.is_away:
+            print("Arm away call after update succeed")
+        else:
+            while not adt.site.alarm_control_panel.is_away:
+                pprint(
+                    "FAIL: arm away call after update failed "
+                    "f{adt.site.alarm_control_panel}"
+                )
+                await adt.wait_for_update()
+            print("Test finally succeeded")
     else:
         print("Arm away failed")
-
-    print()
-    print_site(adt.site)
     await adt.site.async_disarm()
     print("Disarmed")
 

pyadtpulse/__init__.py

@@ -6,6 +6,7 @@
 import re
 import time
 from contextlib import suppress
+from random import randint
 from threading import RLock, Thread
 from typing import List, Optional, Union
 from warnings import warn
@@ -371,22 +372,21 @@ def _check_retry_after(
 
     async def _keepalive_task(self) -> None:
         retry_after = 0
+        response: ClientResponse | None = None
         if self._timeout_task is not None:
             task_name = self._timeout_task.get_name()
         else:
             task_name = f"{KEEPALIVE_TASK_NAME} - possible internal error"
         LOG.debug("creating %s", task_name)
-        response = None
         with self._attribute_lock:
             if self._authenticated is None:
                 raise RuntimeError(
                     "Keepalive task is running without an authenticated event"
                 )
         while self._authenticated.is_set():
             relogin_interval = self.relogin_interval * 60
-            if (
-                relogin_interval != 0
-                and time.time() - self._last_login_time > relogin_interval
+            if relogin_interval != 0 and time.time() - self._last_login_time > randint(
+                int(0.75 * relogin_interval), relogin_interval
             ):
                 LOG.info("Login timeout reached, re-logging in")
                 # FIXME?: should we just pause the task?
@@ -396,13 +396,9 @@ async def _keepalive_task(self) -> None:
                         with suppress(Exception):
                             await self._sync_task
                     await self._do_logout_query()
-                    response = await self._do_login_query()
-                    if response is None:
-                        LOG.error(
-                            "%s could not re-login to ADT Pulse, exiting...", task_name
-                        )
+                    if not await self.async_quick_relogin():
+                        LOG.error("%s could not re-login, exiting", task_name)
                         return
-                    close_response(response)
                     if self._sync_task is not None:
                         coro = self._sync_check_task()
                         self._sync_task = asyncio.create_task(
@@ -509,6 +505,27 @@ def loop(self) -> Optional[asyncio.AbstractEventLoop]:
         """
         return self._pulse_connection.loop
 
+    async def async_quick_relogin(self) -> bool:
+        """Quickly re-login to Pulse.
+
+        Doesn't do device queries or set connected event unless a failure occurs.
+        FIXME:  Should probably just re-work login logic."""
+        response = await self._do_login_query()
+        if not handle_response(response, logging.ERROR, "Could not re-login to Pulse"):
+            await self.async_logout()
+            return False
+        return True
+
+    def quick_relogin(self) -> bool:
+        """Perform quick_relogin synchronously."""
+        coro = self.async_quick_relogin()
+        return asyncio.run_coroutine_threadsafe(
+            coro,
+            self._pulse_connection.check_sync(
+                "Attempting to do call sync quick re-login from async"
+            ),
+        ).result()
+
     async def _do_login_query(self, timeout: int = 30) -> ClientResponse | None:
         try:
             retval = await self._pulse_connection.async_query(
@@ -635,9 +652,9 @@ async def async_logout(self) -> None:
 
     def logout(self) -> None:
         """Log out of ADT Pulse."""
-        loop = self._pulse_connection.loop
-        if loop is None:
-            raise RuntimeError("Attempting to call sync logout without sync login")
+        loop = self._pulse_connection.check_sync(
+            "Attempting to call sync logout without sync login"
+        )
         sync_thread = self._session_thread
 
         coro = self.async_logout()
@@ -655,14 +672,17 @@ async def _sync_check_task(self) -> None:
         LOG.debug("creating %s", task_name)
         response = None
         retry_after = 0
+        last_sync_text = "0-0-0"
         if self._updates_exist is None:
             raise RuntimeError(f"{task_name} started without update event initialized")
-        have_update = False
+        have_updates = False
         while True:
             try:
-                pi = self.site.gateway.poll_interval
-                if have_update:
-                    pi = pi / 2.0
+                self.site.gateway.adjust_backoff_poll_interval()
+                if not have_updates:
+                    pi = self.site.gateway.poll_interval
+                else:
+                    pi = 0.0
                 if retry_after == 0:
                     await asyncio.sleep(pi)
                 else:
@@ -684,35 +704,32 @@ async def _sync_check_task(self) -> None:
                 ):
                     close_response(response)
                     continue
-
+                close_response(response)
                 pattern = r"\d+[-]\d+[-]\d+"
                 if not re.match(pattern, text):
                     LOG.warning(
                         "Unexpected sync check format (%s), forcing re-auth", pattern
                     )
                     LOG.debug("Received %s from ADT Pulse site", text)
-                    close_response(response)
                     await self._do_logout_query()
-                    await self.async_login()
+                    if not await self.async_quick_relogin():
+                        LOG.error("%s couldn't re-login, exiting.", task_name)
                     continue
-
-                # we can have 0-0-0 followed by 1-0-0 followed by 2-0-0, etc
-                # wait until these settle
-                if text.endswith("-0-0"):
-                    LOG.debug(
-                        "Sync token %s indicates updates may exist, requerying", text
-                    )
-                    close_response(response)
-                    have_update = True
+                if text != last_sync_text:
+                    LOG.debug("Updates exist: %s, requerying", text)
+                    last_sync_text = text
+                    have_updates = True
                     continue
-                if have_update:
-                    have_update = False
+                if have_updates:
+                    have_updates = False
                     if await self.async_update() is False:
                         LOG.debug("Pulse data update from %s failed", task_name)
                         continue
                     self._updates_exist.set()
-                LOG.debug("Sync token %s indicates no remote updates to process", text)
-                close_response(response)
+                else:
+                    LOG.debug(
+                        "Sync token %s indicates no remote updates to process", text
+                    )
 
             except asyncio.CancelledError:
                 LOG.debug("%s cancelled", task_name)
@@ -802,11 +819,13 @@ def update(self) -> bool:
         Returns:
             bool: True on success
         """
-        loop = self._pulse_connection.loop
-        if loop is None:
-            raise RuntimeError("Attempting to run sync update from async login")
         coro = self.async_update()
-        return asyncio.run_coroutine_threadsafe(coro, loop).result()
+        return asyncio.run_coroutine_threadsafe(
+            coro,
+            self._pulse_connection.check_sync(
+                "Attempting to run sync update from async login"
+            ),
+        ).result()
 
     @property
     def sites(self) -> List[ADTPulseSite]:

pyadtpulse/alarm_panel.py

@@ -137,7 +137,6 @@ async def _arm(
                     mode,
                     self._status,
                 )
-                return False
             if self._status != ADT_ALARM_OFF and mode != ADT_ALARM_OFF:
                 LOG.warning("Cannot set alarm status from %s to %s", self._status, mode)
                 return False
@@ -195,13 +194,13 @@ def _sync_set_alarm_mode(
         mode: str,
         force_arm: bool = False,
     ) -> bool:
-        loop = connection.loop
-        if loop is None:
-            raise RuntimeError(
-                "Attempting to sync change alarm mode from async session"
-            )
         coro = self._arm(connection, mode, force_arm)
-        return run_coroutine_threadsafe(coro, loop).result()
+        return run_coroutine_threadsafe(
+            coro,
+            connection.check_sync(
+                "Attempting to sync change alarm mode from async session"
+            ),
+        ).result()
 
     def arm_away(self, connection: ADTPulseConnection, force_arm: bool = False) -> bool:
         """Arm the alarm in Away mode.

pyadtpulse/const.py

@@ -1,5 +1,5 @@
 """Constants for pyadtpulse."""
-__version__ = "1.1.2"
+__version__ = "1.1.3"
 DEFAULT_API_HOST = "https://portal.adtpulse.com"
 API_HOST_CA = "https://portal-ca.adtpulse.com"  # Canada
 

pyadtpulse/gateway.py

@@ -128,6 +128,25 @@ def poll_interval(self, new_interval: Optional[float]) -> None:
                 self._current_poll_interval = new_interval
             LOG.debug("Set poll interval to %f", self._initial_poll_interval)
 
+    def adjust_backoff_poll_interval(self) -> None:
+        """Calculates the backoff poll interval.
+
+        Each call will adjust current_poll interval with exponential backoff,
+        unless gateway is online, in which case, poll interval will be reset to
+        initial_poll interval."""
+
+        with self._attribute_lock:
+            if self.is_online:
+                self._current_poll_interval = self._initial_poll_interval
+                return
+            # use an exponential backoff
+            self._current_poll_interval = self._current_poll_interval * 2
+            if self._current_poll_interval > ADT_GATEWAY_OFFLINE_POLL_INTERVAL:
+                self._current_poll_interval = ADT_DEFAULT_POLL_INTERVAL
+            LOG.debug(
+                "Setting current poll interval to %f", self._current_poll_interval
+            )
+
     def set_gateway_attributes(self, gateway_attributes: dict[str, str]) -> None:
         """Set gateway attributes from dictionary.