python-selve-new 2.5.6__tar.gz → 2.5.8__tar.gz

{python_selve_new-2.5.6 → python_selve_new-2.5.8}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: python-selve-new
-Version: 2.5.6
+Version: 2.5.8
 Summary: Python library for interfacing with selve devices using the USB-RF controller. Written completely new.
 Home-page: https://github.com/Kannix2005/python-selve-new
 Author: Stefan Altheimer

{python_selve_new-2.5.6 → python_selve_new-2.5.8}/python_selve_new.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: python-selve-new
-Version: 2.5.6
+Version: 2.5.8
 Summary: Python library for interfacing with selve devices using the USB-RF controller. Written completely new.
 Home-page: https://github.com/Kannix2005/python-selve-new
 Author: Stefan Altheimer

{python_selve_new-2.5.6 → python_selve_new-2.5.8}/selve/__init__.py

@@ -778,6 +778,13 @@ class Selve:
         # Rebuild transport for a clean connection (avoids stale StreamReader state
         # left over from _probe_port, which explains why USB-replug was needed).
         await self._teardown_transport()
+        # Flush any stale messages left in the receive queue from the probe phase
+        # (unsolicited gateway events or responses the cancelled dispatch task never
+        # consumed).  If we don't do this, the dispatch loop matches those old
+        # messages against the new discover() command futures, resolving them with
+        # the wrong response object and causing silent discover failures.
+        self.rxQ = asyncio.Queue()
+        self._pending_futures.clear()
         await self.setEvents(0,0,0,0,0)
         rdy = await self.gatewayReady()
         if rdy:

{python_selve_new-2.5.6 → python_selve_new-2.5.8}/selve/_version.py

@@ -18,7 +18,7 @@ version_tuple: tuple[int | str, ...]
 commit_id: str | None
 __commit_id__: str | None
 
-__version__ = version = '2.5.6'
-__version_tuple__ = version_tuple = (2, 5, 6)
+__version__ = version = '2.5.8'
+__version_tuple__ = version_tuple = (2, 5, 8)
 
-__commit_id__ = commit_id = 'g74b26e3d1'
+__commit_id__ = commit_id = 'g2562749e3'

{python_selve_new-2.5.6 → python_selve_new-2.5.8}/selve/util/serial_transport.py

@@ -5,6 +5,8 @@ from typing import Optional
 import serialx
 from serialx import Parity
 
+_READLINE_TIMEOUT = 12.0  # seconds — gateway goes silent during RF motor ops
+
 
 class SerialTransport:
     """Async serial transport using serialx (replaces pyserial + background thread)."""
@@ -36,6 +38,7 @@ class SerialTransport:
 
     async def ensure_open(self) -> None:
         if not self.is_open:
+            self._logger.info("Serial: opening %s", self._port)
             self._reader, self._writer = await serialx.open_serial_connection(
                 url=self._port,
                 baudrate=self._baudrate,
@@ -46,8 +49,10 @@ class SerialTransport:
                 rtscts=False,
                 dsrdtr=False,
             )
+            self._logger.info("Serial: %s opened, reader=%r writer=%r", self._port, self._reader, self._writer)
 
     async def close(self) -> None:
+        self._logger.info("Serial: closing %s", self._port)
         try:
             if self._writer and not self._writer.is_closing():
                 self._writer.close()
@@ -56,34 +61,60 @@ class SerialTransport:
             self._logger.debug("Serial close failed", exc_info=True)
         self._reader = None
         self._writer = None
+        self._logger.info("Serial: %s closed", self._port)
 
     async def start_reader(self, rx_queue: asyncio.Queue) -> None:
         """Opens the serial port and starts the async reader task."""
         await self.ensure_open()
         self._rx_queue = rx_queue
         if self._reader_task and not self._reader_task.done():
+            self._logger.info("Serial: reader task already running")
             return
+        self._logger.info("Serial: starting reader task, reader=%r", self._reader)
         self._reader_task = asyncio.create_task(
             self._reader_loop(), name="selve-serial-reader"
         )
 
     async def stop_reader(self) -> None:
         if self._reader_task:
+            self._logger.info("Serial: stopping reader task")
             self._reader_task.cancel()
             try:
                 await self._reader_task
             except asyncio.CancelledError:
                 pass
             self._reader_task = None
+            self._logger.info("Serial: reader task stopped")
 
     async def _reader_loop(self) -> None:
+        self._logger.info("Serial: reader loop started, reader=%r at_eof=%s",
+                          self._reader,
+                          self._reader.at_eof() if self._reader else "N/A")
         buffer = ""
+        iteration = 0
         while True:
             try:
                 if self._reader is None:
+                    self._logger.warning("Serial: reader is None in loop, reopening")
                     await self.ensure_open()
-                line_bytes = await self._reader.readline()
+                self._logger.debug("Serial: awaiting readline (iter=%d, buf=%r)", iteration, buffer)
+                line_bytes = await asyncio.wait_for(
+                    self._reader.readline(), timeout=_READLINE_TIMEOUT
+                )
+                self._logger.debug("Serial: readline returned %d bytes (iter=%d)", len(line_bytes), iteration)
+                iteration += 1
+            except asyncio.TimeoutError:
+                self._logger.warning(
+                    "Serial: readline timeout after %.0fs (iter=%d, buf=%r) — reconnecting",
+                    _READLINE_TIMEOUT, iteration, buffer,
+                )
+                buffer = ""
+                await self.close()
+                await asyncio.sleep(1.0)
+                await self.ensure_open()
+                continue
             except asyncio.CancelledError:
+                self._logger.info("Serial: reader loop cancelled")
                 break
             except (OSError, EOFError) as exc:
                 self._logger.error("Serial read error: %s", exc)
@@ -95,6 +126,8 @@ class SerialTransport:
                 continue
 
             if not line_bytes:
+                self._logger.debug("Serial: readline returned empty bytes (EOF?), reader.at_eof=%s",
+                                   self._reader.at_eof() if self._reader else "N/A")
                 await asyncio.sleep(0.01)
                 continue