feat: update data on ack

src/pysaleryd/client.py

@@ -27,7 +27,7 @@ def __init__(
         self._handlers = set()
         self._socket = WSClient(self._session, self._url, self._port, self._handler)
         self._message_handler_task = asyncio.create_task(self._message_handler())
-        self._data_handler_task = asyncio.create_task(self._call_handlers())
+        self._data_handler_task = asyncio.create_task(self._call_handlers_task())
         self._incoming_queue = asyncio.queues.Queue()
 
     @property
@@ -48,16 +48,20 @@ async def __aenter__(self):
     async def __aexit__(self, _type, value, traceback):
         self.disconnect()
 
-    async def _call_handlers(self):
+    async def _call_handlers_task(self):
         """Call handlers with data"""
         while True:
-            for handler in self._handlers:
-                try:
-                    handler(self._data)
-                except Exception:
-                    _LOGGER.warning("Failed to call handler", exc_info=True)
+            self._call_handlers()
             await asyncio.sleep(self._update_interval)
 
+    def _call_handlers(self):
+        """Call handlers with data"""
+        for handler in self._handlers:
+            try:
+                handler(self._data)
+            except Exception:
+                _LOGGER.warning("Failed to call handler", exc_info=True)
+
     async def _handler(
         self, signal: Signal, data: str, state: "State" = None
     ):  # pylint: disable W0613
@@ -70,7 +74,7 @@ async def _message_handler(self):
                 msg = await self._incoming_queue.get()
                 # update state
                 # if ack force push state to handler
-                (key, value) = Parser.from_str(msg)
+                (key, value, is_ack) = Parser.from_str(msg)
 
                 if key in ["*EA", "*EB", "*EZ"]:
                     if key == "*EA":
@@ -82,6 +86,8 @@ async def _message_handler(self):
                         self._data["*EB"] = self._error_cache.data
                 else:
                     self._data[key] = value
+                    if is_ack:
+                        self._call_handlers()
             except ParseError:
                 pass
 

src/pysaleryd/utils.py

@@ -37,11 +37,13 @@ def from_str(msg: str):
         Returns:
             (key, value): parsed message key and value
         """
+        is_ack_message = False
         try:
             if msg[0] == "#":
                 if msg[1] == "$":
                     # ack message, strip ack char and treat as state update
                     msg = msg[1::]
+                    is_ack_message = True
                 value = msg[1::].split(":")[1].strip()
                 value = int(value) if value.isnumeric() else value
 
@@ -53,7 +55,7 @@ def from_str(msg: str):
                         for v in value.split("+")
                     ]
                 key = msg[1::].split(":")[0]
-                parsed = (key, value)
+                parsed = (key, value, is_ack_message)
                 return parsed
         except Exception as exc:
             raise ParseError(f"Failed to parse message {msg}") from exc

tests/test_parser.py

@@ -19,7 +19,7 @@ def _parser() -> Parser:
 
 def test_parse_int_from_list_str(parser: Parser):
     """Test parsing int list"""
-    (key, value) = parser.from_str("#MF: 1+ 0+ 2+30\r")
+    (key, value, _) = parser.from_str("#MF: 1+ 0+ 2+30\r")
     assert key == "MF"
     assert isinstance(value, list)
     assert value[0] == 1
@@ -30,20 +30,20 @@ def test_parse_int_from_list_str(parser: Parser):
 
 def test_parse_int_from_str(parser: Parser):
     """Test parsing int"""
-    (key, value) = parser.from_str("#*XX:0\r")
+    (key, value, _) = parser.from_str("#*XX:0\r")
     assert key == "*XX"
     assert isinstance(value, int)
     assert value == 0
 
 
 def test_parse_str_from_str(parser: Parser):
     """Test parsing str"""
-    (key, value) = parser.from_str("#*XX:xxx\r")
+    (key, value, _) = parser.from_str("#*XX:xxx\r")
     assert key == "*XX"
     assert isinstance(value, str)
     assert value == "xxx"
 
-    (key, value) = parser.from_str("#*XX:    1.x.1\r")
+    (key, value, _) = parser.from_str("#*XX:    1.x.1\r")
     assert key == "*XX"
     assert isinstance(value, str)
     assert value == "1.x.1"