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

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

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: python-selve-new
-Version: 2.5.8
+Version: 2.5.10
 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.8 → python_selve_new-2.5.10}/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.8 → python_selve_new-2.5.10}/selve/__init__.py

@@ -1106,9 +1106,9 @@ class Selve:
                     dev.state = MovementState.UP_ON
                 elif response.command is DriveCommandCommeo.STOP:
                     dev.state = MovementState.STOPPED_OFF
-                elif response.command is DriveCommandCommeo.DRIVESTEPDOWN:
+                elif response.command is DriveCommandCommeo.STEPDOWN:
                     dev.state = MovementState.DOWN_ON
-                elif response.command is DriveCommandCommeo.DRIVESTEPUP:
+                elif response.command is DriveCommandCommeo.STEPUP:
                     dev.state = MovementState.UP_ON
                 self.addOrUpdateDevice(dev, SelveTypes.DEVICE)
             for id in response.failedIds:

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

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

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

@@ -5,7 +5,37 @@ from typing import Optional
 import serialx
 from serialx import Parity
 
-_READLINE_TIMEOUT = 12.0  # seconds — gateway goes silent during RF motor ops
+# 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:
@@ -49,7 +79,7 @@ class SerialTransport:
                 rtscts=False,
                 dsrdtr=False,
             )
-            self._logger.info("Serial: %s opened, reader=%r writer=%r", self._port, self._reader, self._writer)
+            self._logger.info("Serial: %s opened", self._port)
 
     async def close(self) -> None:
         self._logger.info("Serial: closing %s", self._port)
@@ -70,7 +100,7 @@ class SerialTransport:
         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._logger.info("Serial: starting reader task")
         self._reader_task = asyncio.create_task(
             self._reader_loop(), name="selve-serial-reader"
         )
@@ -87,28 +117,31 @@ class SerialTransport:
             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
+        """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:
-                    self._logger.warning("Serial: reader is None in loop, reopening")
-                    await self.ensure_open()
-                self._logger.debug("Serial: awaiting readline (iter=%d, buf=%r)", iteration, buffer)
-                line_bytes = await asyncio.wait_for(
-                    self._reader.readline(), timeout=_READLINE_TIMEOUT
+                await self.ensure_open()
+                assert self._reader is not None
+                chunk = await asyncio.wait_for(
+                    self._reader.read(4096), timeout=_IDLE_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,
+                    "Serial: no data for %.0fs — reconnecting", _IDLE_TIMEOUT
                 )
-                buffer = ""
+                buffer = b""
                 await self.close()
                 await asyncio.sleep(1.0)
                 await self.ensure_open()
@@ -125,21 +158,17 @@ class SerialTransport:
                 await asyncio.sleep(1)
                 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")
+            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.10/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"