python-selve-new 2.5.7__tar.gz → 2.5.9__tar.gz

{python_selve_new-2.5.7 → python_selve_new-2.5.9}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: python-selve-new
-Version: 2.5.7
+Version: 2.5.9
 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.7 → python_selve_new-2.5.9}/python_selve_new.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: python-selve-new
-Version: 2.5.7
+Version: 2.5.9
 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.7 → python_selve_new-2.5.9}/python_selve_new.egg-info/SOURCES.txt

@@ -101,6 +101,7 @@ tests/unit/test_selve_main_class_extensive.py
 tests/unit/test_sender_commands_extended.py
 tests/unit/test_sensim_commands_extended.py
 tests/unit/test_sensor_commands_extended.py
+tests/unit/test_serial_transport.py
 tests/unit/test_service_command_errors.py
 tests/unit/test_service_commands.py
 tests/unit/test_util.py

{python_selve_new-2.5.7 → python_selve_new-2.5.9}/selve/_version.py

@@ -18,7 +18,7 @@ version_tuple: tuple[int | str, ...]
 commit_id: str | None
 __commit_id__: str | None
 
-__version__ = version = '2.5.7'
-__version_tuple__ = version_tuple = (2, 5, 7)
+__version__ = version = '2.5.9'
+__version_tuple__ = version_tuple = (2, 5, 9)
 
-__commit_id__ = commit_id = 'gaf58df608'
+__commit_id__ = commit_id = 'gc04157d25'

{python_selve_new-2.5.7 → python_selve_new-2.5.9}/selve/util/serial_transport.py

@@ -5,6 +5,38 @@ from typing import Optional
 import serialx
 from serialx import Parity
 
+# Any data chunk arriving within this window extends the deadline.
+# Only a truly dead/disconnected port triggers a reconnect.
+_IDLE_TIMEOUT = 60.0
+
+# The gateway protocol uses XML-RPC framing. Every message ends with one of
+# these two tags; there are no other root-level closing tags in the protocol.
+_END_TAGS = (b"</methodResponse>", b"</methodCall>")
+
+
+def _extract_messages(buffer: bytes) -> tuple:
+    """Extract all complete XML messages from *buffer*.
+
+    Returns (messages, remaining_bytes) where *messages* is a list of decoded
+    strings and *remaining_bytes* is the unconsumed tail of the buffer.
+    """
+    messages: list = []
+    while True:
+        earliest_end = None
+        for tag in _END_TAGS:
+            pos = buffer.find(tag)
+            if pos >= 0:
+                end = pos + len(tag)
+                if earliest_end is None or end < earliest_end:
+                    earliest_end = end
+        if earliest_end is None:
+            break
+        msg = buffer[:earliest_end].decode(errors="ignore").strip()
+        buffer = buffer[earliest_end:]
+        if msg:
+            messages.append(msg)
+    return messages, buffer
+
 
 class SerialTransport:
     """Async serial transport using serialx (replaces pyserial + background thread)."""
@@ -36,6 +68,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 +79,10 @@ class SerialTransport:
                 rtscts=False,
                 dsrdtr=False,
             )
+            self._logger.info("Serial: %s opened", self._port)
 
     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 +91,63 @@ 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")
         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:
-        buffer = ""
+        """Read raw bytes and dispatch complete XML messages by framing on closing tags.
+
+        Using read() instead of readline() avoids depending on \\n as a message
+        delimiter. The Selve protocol is XML-RPC: every gateway message ends with
+        either </methodResponse> or </methodCall>. We scan the byte buffer for
+        these tags and dispatch as soon as a complete message is available.
+
+        A 60-second idle timeout (no bytes at all) triggers a reconnect. This is
+        far more conservative than the old 12-second readline hack and only fires
+        when the serial port is truly dead.
+        """
+        self._logger.info("Serial: reader loop started")
+        buffer = b""
         while True:
             try:
-                if self._reader is None:
-                    await self.ensure_open()
-                line_bytes = await self._reader.readline()
+                await self.ensure_open()
+                assert self._reader is not None
+                chunk = await asyncio.wait_for(
+                    self._reader.read(4096), timeout=_IDLE_TIMEOUT
+                )
+            except asyncio.TimeoutError:
+                self._logger.warning(
+                    "Serial: no data for %.0fs — reconnecting", _IDLE_TIMEOUT
+                )
+                buffer = b""
+                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)
@@ -94,19 +158,17 @@ class SerialTransport:
                 await asyncio.sleep(1)
                 continue
 
-            if not line_bytes:
+            if not chunk:
                 await asyncio.sleep(0.01)
                 continue
 
-            decoded = line_bytes.decode(errors="ignore").strip()
-            if decoded == "":
-                if buffer and self._rx_queue:
-                    self._logger.debug("Serial RX: %s", buffer)
-                    await self._rx_queue.put(buffer)
-                    buffer = ""
-                continue
+            buffer += chunk
 
-            buffer += decoded
+            new_messages, buffer = _extract_messages(buffer)
+            for msg in new_messages:
+                self._logger.debug("Serial RX: %s", msg)
+                if self._rx_queue:
+                    await self._rx_queue.put(msg)
 
     async def write(self, payload: bytes) -> None:
         await self.ensure_open()

python_selve_new-2.5.9/tests/unit/test_serial_transport.py

@@ -0,0 +1,143 @@
+import asyncio
+import pytest
+from unittest.mock import AsyncMock, MagicMock, patch
+
+from selve.util.serial_transport import _extract_messages
+
+
+# ---------------------------------------------------------------------------
+# Pure synchronous tests for _extract_messages
+# ---------------------------------------------------------------------------
+
+def test_single_method_response():
+    xml = b"<methodResponse><array><string>selve.GW.service.ping</string></array></methodResponse>"
+    msgs, remaining = _extract_messages(xml)
+    assert len(msgs) == 1
+    assert "</methodResponse>" in msgs[0]
+    assert "selve.GW.service.ping" in msgs[0]
+    assert remaining == b""
+
+
+def test_single_method_call():
+    xml = b"<methodCall><methodName>selve.GW.event.device</methodName><array></array></methodCall>"
+    msgs, remaining = _extract_messages(xml)
+    assert len(msgs) == 1
+    assert "</methodCall>" in msgs[0]
+    assert "event.device" in msgs[0]
+    assert remaining == b""
+
+
+def test_two_messages_in_one_chunk():
+    chunk = (
+        b"<methodResponse><array><string>selve.GW.service.ping</string></array></methodResponse>"
+        b"<methodCall><methodName>selve.GW.event.dutyCycle</methodName><array></array></methodCall>"
+    )
+    msgs, remaining = _extract_messages(chunk)
+    assert len(msgs) == 2
+    assert any("methodResponse" in m for m in msgs)
+    assert any("methodCall" in m for m in msgs)
+    assert remaining == b""
+
+
+def test_incomplete_message_stays_in_buffer():
+    partial = b"<methodResponse><array><string>selve.GW.service.ping</string></array>"
+    msgs, remaining = _extract_messages(partial)
+    assert msgs == []
+    assert remaining == partial
+
+
+def test_message_split_across_chunks():
+    xml = b"<methodResponse><array><string>selve.GW.service.ping</string></array></methodResponse>"
+    mid = len(xml) // 2
+    # First chunk: no complete message yet
+    msgs1, buf = _extract_messages(xml[:mid])
+    assert msgs1 == []
+    # Second chunk completes the message
+    msgs2, remaining = _extract_messages(buf + xml[mid:])
+    assert len(msgs2) == 1
+    assert "</methodResponse>" in msgs2[0]
+    assert remaining == b""
+
+
+def test_xml_preamble_included_in_message():
+    xml = (
+        b'<?xml version="1.0"? encoding="UTF-8">'
+        b"<methodResponse><array><string>selve.GW.service.ping</string></array></methodResponse>"
+    )
+    msgs, remaining = _extract_messages(xml)
+    assert len(msgs) == 1
+    assert "methodResponse" in msgs[0]
+
+
+def test_garbage_before_message_is_included():
+    """Leading whitespace/garbage bytes before the opening tag stay in the message."""
+    xml = b"\r\n  <methodResponse><array></array></methodResponse>"
+    msgs, remaining = _extract_messages(xml)
+    assert len(msgs) == 1
+    assert "methodResponse" in msgs[0]
+
+
+def test_empty_buffer():
+    msgs, remaining = _extract_messages(b"")
+    assert msgs == []
+    assert remaining == b""
+
+
+def test_fault_response_uses_method_response_tag():
+    """Fault responses are wrapped in <methodResponse>, same closing tag."""
+    xml = b"<methodResponse><fault><array><string>Error</string><int>-1</int></array></fault></methodResponse>"
+    msgs, remaining = _extract_messages(xml)
+    assert len(msgs) == 1
+    assert "fault" in msgs[0]
+    assert remaining == b""
+
+
+# ---------------------------------------------------------------------------
+# Async test: idle timeout triggers reconnect
+# ---------------------------------------------------------------------------
+
+@pytest.mark.asyncio
+async def test_idle_timeout_triggers_reconnect():
+    """If no data arrives for _IDLE_TIMEOUT seconds, close+ensure_open are called."""
+    import selve.util.serial_transport as st
+    from selve.util.serial_transport import SerialTransport
+
+    transport = SerialTransport(port="COM_TEST", logger=MagicMock())
+
+    # Reader that never produces data (simulates dead port)
+    reader = asyncio.StreamReader()
+    transport._reader = reader
+    transport._writer = MagicMock(is_closing=MagicMock(return_value=False))
+    transport._rx_queue = asyncio.Queue()
+
+    close_calls = []
+    ensure_calls = []
+
+    async def fake_close():
+        close_calls.append(1)
+        transport._reader = None
+        transport._writer = None
+
+    async def fake_ensure():
+        ensure_calls.append(1)
+        transport._reader = asyncio.StreamReader()
+        transport._writer = MagicMock(is_closing=MagicMock(return_value=False))
+
+    transport.close = fake_close
+    transport.ensure_open = fake_ensure
+
+    original = st._IDLE_TIMEOUT
+    st._IDLE_TIMEOUT = 0.05
+    try:
+        task = asyncio.create_task(transport._reader_loop())
+        await asyncio.sleep(0.25)
+        task.cancel()
+        try:
+            await task
+        except asyncio.CancelledError:
+            pass
+    finally:
+        st._IDLE_TIMEOUT = original
+
+    assert len(close_calls) >= 1, "close() should be called on idle timeout"
+    assert len(ensure_calls) >= 1, "ensure_open() should be called after reconnect"