python-selve-new 2.5.11__tar.gz → 2.5.12__tar.gz

{python_selve_new-2.5.11 → python_selve_new-2.5.12}/CHANGELOG.md

@@ -2,6 +2,19 @@
 
 All notable changes to this project will be documented in this file.
 
+## [2.5.12] - 2026-06-12
+
+### Changed
+- **Response-paced command transmission**: the TX loop now waits for the previous command's response (with a 5s safety timeout) instead of sleeping a fixed 100ms after every serial write. Command round-trips drop from ~130ms to gateway speed (~30-40ms); full device discovery is roughly 3x faster. Verified against live gateway hardware.
+- **Device-aware update callbacks**: `register_callback` callbacks may now accept the changed device as a single positional argument, so consumers can update only the affected entity. Parameterless callbacks keep working unchanged. Callbacks are now fired only when a device actually changed (from `addOrUpdateDevice`), no longer after every gateway response, and a failing callback no longer breaks the dispatch of the remaining ones.
+- Hot-path logging now uses lazy `%s` formatting; the malformed-XML-header workaround only runs when the broken header is actually present.
+
+### Fixed
+- **Gateway error responses stalled callers for 10s**: a fault reply from the gateway never resolved the pending command future, so `executeCommandSyncWithResponse` always ran into its full 10s timeout (and another 10s on retry). Error responses now resolve the waiting future with `False` immediately.
+- `updateAllDevices()` crashed with `AttributeError`: it iterated dict keys (ints) instead of device objects.
+- `processTeachResponse` was called without `await`, so teach/scan result processing (including the event callback and event queue delivery) never actually ran.
+- Sender events were stored into the sensor device registry (`SelveTypes.SENSOR` instead of `SelveTypes.SENDER`), overwriting sensors that shared the same id.
+
 ## [2.5.0] - 2026-02-11
 
 ### Added

{python_selve_new-2.5.11 → python_selve_new-2.5.12}/PKG-INFO

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

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

@@ -89,6 +89,7 @@ tests/unit/test_mock_commands.py
 tests/unit/test_mock_devices_and_groups.py
 tests/unit/test_mock_sensors_and_senders.py
 tests/unit/test_param_commands_extended.py
+tests/unit/test_perf_improvements.py
 tests/unit/test_port_discovery.py
 tests/unit/test_selve_advanced_coverage.py
 tests/unit/test_selve_core_coverage.py

{python_selve_new-2.5.11 → python_selve_new-2.5.12}/selve/__init__.py

@@ -12,6 +12,7 @@ except ImportError:
         __version__ = "unknown"
 
 import asyncio
+import inspect
 import logging
 import time
 from collections import deque
@@ -60,7 +61,8 @@ class Selve:
 
     def __init__(self, port=None, discover=True, develop=False, logger=None, loop=None):
         # Gateway state
-        self._callbacks = set()
+        # callback -> whether it accepts the changed device as argument
+        self._callbacks: dict = {}
         self._eventCallbacks = set()
         self.lastLogEvent = None
         self.state = None
@@ -301,6 +303,17 @@ class Selve:
                     self._pending_futures.append(future)
 
                 await self._sendCommandToGateway(command)
+
+                if future is not None:
+                    # Pace transmissions by the response instead of a fixed
+                    # delay: the gateway answers in order, so the next command
+                    # may go out as soon as this one's response has arrived.
+                    # A timeout keeps a lost response from stalling the queue.
+                    await asyncio.wait({future}, timeout=5)
+                else:
+                    # Fire-and-forget commands still produce a gateway reply;
+                    # keep a small gap so the gateway is not flooded.
+                    await asyncio.sleep(0.05)
             except asyncio.CancelledError:
                 break
             except Exception as e:
@@ -325,17 +338,13 @@ class Selve:
             try:
                 resp = await self.processResponse(msg)
                 if isinstance(resp, ErrorResponse):
-                    resp = False
-
-                if resp not in (False, True, None):
-                    while self._pending_futures:
-                        fut = self._pending_futures.popleft()
-                        if fut.cancelled():
-                            continue
-                        if not fut.done():
-                            fut.set_result(resp)
-                            break
-                    else:
+                    # A fault is the gateway's reply to a command: resolve the
+                    # waiting future with False right away instead of letting
+                    # the caller run into its 10s timeout.
+                    if not self._resolve_next_future(False):
+                        self._LOGGER.debug("(Selve RX): error response without pending future -> %s", resp)
+                elif resp not in (False, True, None):
+                    if not self._resolve_next_future(resp):
                         self._LOGGER.debug("(Selve RX): response without pending future -> %s", resp)
                 self.rxQ.task_done()
             except Exception as e:
@@ -346,6 +355,17 @@ class Selve:
                     pass
 
 
+    def _resolve_next_future(self, result):
+        """Resolve the oldest pending command future with the given result."""
+        while self._pending_futures:
+            fut = self._pending_futures.popleft()
+            if fut.cancelled():
+                continue
+            if not fut.done():
+                fut.set_result(result)
+                return True
+        return False
+
     async def stopWorker(self):
         self._LOGGER.debug("Stopping worker")
         self._pauseWorker.set()
@@ -386,13 +406,37 @@ class Selve:
         return True
 
 
-    def register_callback(self, callback: Callable[[], None]) -> None:
-        """Register callback, called when Roller changes state."""
-        self._callbacks.add(callback)
+    def register_callback(self, callback: Callable) -> None:
+        """Register callback, called when a device changes state.
 
-    def remove_callback(self, callback: Callable[[], None]) -> None:
+        The callback may optionally accept the changed device as its single
+        positional argument; parameterless callbacks keep working and are
+        invoked without arguments.
+        """
+        accepts_device = True
+        try:
+            inspect.signature(callback).bind(None)
+        except TypeError:
+            accepts_device = False
+        except ValueError:
+            # Builtins without introspectable signature: assume no args
+            accepts_device = False
+        self._callbacks[callback] = accepts_device
+
+    def remove_callback(self, callback: Callable) -> None:
         """Remove previously registered callback."""
-        self._callbacks.discard(callback)
+        self._callbacks.pop(callback, None)
+
+    def _fire_callbacks(self, device=None) -> None:
+        """Notify registered callbacks, passing the changed device if known."""
+        for callback, accepts_device in list(self._callbacks.items()):
+            try:
+                if accepts_device:
+                    callback(device)
+                else:
+                    callback()
+            except Exception:
+                self._LOGGER.exception("Error in update callback")
 
     def register_event_callback(self, callback: Callable[[], None]) -> None:
         """Register callback, called when other events take place."""
@@ -418,7 +462,7 @@ class Selve:
 
     async def _sendCommandToGateway(self, command: Command):
         commandstr = command.serializeToXML()
-        self._LOGGER.debug('Gateway writing: ' + str(commandstr))
+        self._LOGGER.debug('Gateway writing: %s', commandstr)
         try:
             if self._transport is None:
                 if self._port is None:
@@ -426,11 +470,9 @@ class Selve:
                 await self._build_transport(self._port)
 
             await self._transport.write(commandstr)
-            # small pause to give the gateway time to answer
-            await asyncio.sleep(0.1)
 
         except (OSError, IOError) as se:
-            self._LOGGER.info('Serial error, trying to reconnect once... ' + str(se))
+            self._LOGGER.info('Serial error, trying to reconnect once... %s', se)
             await self.recover()
 
             try:
@@ -438,13 +480,12 @@ class Selve:
                 if self._transport is None and self._port is not None:
                     await self._build_transport(self._port)
                 await self._transport.write(commandstr)
-                await asyncio.sleep(0.1)
-            
+
             except Exception as e:
-                self._LOGGER.error("error communicating: " + str(e) + " ; Please restart the integration!")
+                self._LOGGER.error("error communicating: %s ; Please restart the integration!", e)
 
         except Exception as e:
-            self._LOGGER.error("error communicating: " + str(e) + " ; Please restart the integration!")
+            self._LOGGER.error("error communicating: %s ; Please restart the integration!", e)
 
     async def processResponse(self, xmlstr):
         """Processes an XML String into a response object. Returns False if something went wrong or the gateway returned an error."""
@@ -453,11 +494,13 @@ class Selve:
         # return the ready to eat response
 
         # The selve device sometimes answers a badformed header. This is a patch
-        xmlstr = str(xmlstr).replace('<?xml version="1.0"? encoding="UTF-8">', '<?xml version="1.0" encoding="UTF-8"?>')
+        xmlstr = str(xmlstr)
+        if '<?xml version="1.0"? encoding="UTF-8">' in xmlstr:
+            xmlstr = xmlstr.replace('<?xml version="1.0"? encoding="UTF-8">', '<?xml version="1.0" encoding="UTF-8"?>')
         try:
             res = untangle.parse(xmlstr)
         except Exception as e:
-            self._LOGGER.error("Error in XML: " + str(e) + " : " + xmlstr)
+            self._LOGGER.error("Error in XML: %s : %s", e, xmlstr)
             return False
         try:
             if not hasattr(res, 'methodResponse') and not hasattr(res, 'methodCall'):
@@ -492,16 +535,14 @@ class Selve:
             if isinstance(response, SenderTeachResultResponse) \
                 or isinstance(response, SensorTeachResultResponse)\
                 or isinstance(response, DeviceScanResultResponse):
-                self.processTeachResponse(response)
+                await self.processTeachResponse(response)
                 return True
 
-            for callback in self._callbacks:
-                callback()
             return response
 
 
         except Exception as e:
-            self._LOGGER.error("Error in response processing: " + str(e) + " : " + xmlstr)
+            self._LOGGER.error("Error in response processing: %s : %s", e, xmlstr)
             return False
 
     def create_error(self, obj):
@@ -901,13 +942,13 @@ class Selve:
 
 
     async def updateAllDevices(self):
-        for device in self.devices[SelveTypes.DEVICE.value]:
+        for device in list(self.devices[SelveTypes.DEVICE.value].values()):
             await self.updateCommeoDeviceValues(device.id)
-        for sensor in self.devices[SelveTypes.SENSOR.value]:
+        for sensor in list(self.devices[SelveTypes.SENSOR.value].values()):
             await self.updateSensorValuesAsync(sensor.id)
-        for senSim in self.devices[SelveTypes.SENSIM.value]:
+        for senSim in list(self.devices[SelveTypes.SENSIM.value].values()):
             await self.updateSenSimValuesAsync(senSim.id)
-        for sender in self.devices[SelveTypes.SENDER.value]:
+        for sender in list(self.devices[SelveTypes.SENDER.value].values()):
             await self.updateSenderValuesAsync(sender.id)
 
 
@@ -917,8 +958,7 @@ class Selve:
         # add in gateway
 
         # if there is a callback for updates, call it
-        for callback in self._callbacks:
-            callback()
+        self._fire_callbacks(device)
 
     def getDevice(self, id: int, type: SelveTypes) -> SelveDevice | SelveSensor | SelveSender | SelveGroup | SelveSenSim | None:
         if id in self.devices[type.value]:
@@ -1057,7 +1097,7 @@ class Selve:
 
             sender.lastEvent = response.event
             sender.name = response.senderName
-            self.addOrUpdateDevice(sender, SelveTypes.SENSOR)
+            self.addOrUpdateDevice(sender, SelveTypes.SENDER)
 
         if isinstance(response, LogEventResponse):
             self.lastLogEvent = response
@@ -1118,9 +1158,6 @@ class Selve:
                 dev.unreachable = True
                 self.addOrUpdateDevice(dev, SelveTypes.DEVICE)
 
-        for callback in self._callbacks:
-            callback()
-
 
     ### Service
 

{python_selve_new-2.5.11 → python_selve_new-2.5.12}/selve/_version.py

@@ -18,7 +18,7 @@ version_tuple: tuple[int | str, ...]
 commit_id: str | None
 __commit_id__: str | None
 
-__version__ = version = '2.5.11'
-__version_tuple__ = version_tuple = (2, 5, 11)
+__version__ = version = '2.5.12'
+__version_tuple__ = version_tuple = (2, 5, 12)
 
-__commit_id__ = commit_id = 'g91d08a72a'
+__commit_id__ = commit_id = 'g62288d04e'

python_selve_new-2.5.12/tests/unit/test_perf_improvements.py

@@ -0,0 +1,194 @@
+"""
+Tests for the performance improvements:
+- response-paced TX loop (no fixed 100ms delay)
+- ErrorResponse resolves the pending future immediately
+- callbacks receive the changed device (with zero-arg compatibility)
+- updateAllDevices iterates device objects, not ids
+"""
+import asyncio
+import time
+from unittest.mock import Mock, AsyncMock
+
+import pytest
+
+from selve import Selve
+from selve.commands.service import ServicePing
+from selve.util.errors import ErrorResponse
+from selve.util.protocol import SelveTypes
+
+
+def _make_selve():
+    return Selve(port=None, discover=False, develop=False, logger=Mock())
+
+
+class TestResolveNextFuture:
+    def test_resolves_oldest_pending_future(self):
+        selve = _make_selve()
+        loop = asyncio.new_event_loop()
+        try:
+            fut1 = loop.create_future()
+            fut2 = loop.create_future()
+            selve._pending_futures.append(fut1)
+            selve._pending_futures.append(fut2)
+
+            assert selve._resolve_next_future("result") is True
+            assert fut1.result() == "result"
+            assert not fut2.done()
+        finally:
+            loop.close()
+
+    def test_skips_cancelled_futures(self):
+        selve = _make_selve()
+        loop = asyncio.new_event_loop()
+        try:
+            fut1 = loop.create_future()
+            fut1.cancel()
+            fut2 = loop.create_future()
+            selve._pending_futures.append(fut1)
+            selve._pending_futures.append(fut2)
+
+            assert selve._resolve_next_future(False) is True
+            assert fut2.result() is False
+        finally:
+            loop.close()
+
+    def test_returns_false_without_pending_future(self):
+        selve = _make_selve()
+        assert selve._resolve_next_future("x") is False
+
+
+@pytest.mark.asyncio
+async def test_error_response_resolves_future_immediately():
+    """A gateway fault must resolve the waiting command future with False
+    instead of letting the caller run into its 10s timeout."""
+    selve = _make_selve()
+    selve.rxQ = asyncio.Queue()
+
+    async def fake_process(msg):
+        return ErrorResponse("Method not supported", 2)
+
+    selve.processResponse = fake_process
+
+    future = asyncio.get_running_loop().create_future()
+    selve._pending_futures.append(future)
+    await selve.rxQ.put("<dummy/>")
+
+    task = asyncio.create_task(selve._dispatch_loop())
+    try:
+        for _ in range(100):
+            if future.done():
+                break
+            await asyncio.sleep(0.01)
+        assert future.done(), "future was not resolved by the error response"
+        assert future.result() is False
+    finally:
+        selve._stopThread.set()
+        task.cancel()
+        try:
+            await task
+        except asyncio.CancelledError:
+            pass
+
+
+@pytest.mark.asyncio
+async def test_tx_loop_waits_for_response_before_next_command():
+    """The TX loop must not send the next command before the previous
+    command's response future is resolved."""
+    selve = _make_selve()
+    selve.txQ = asyncio.Queue()
+    send_times = []
+
+    async def fake_send(command):
+        send_times.append(time.monotonic())
+
+    selve._sendCommandToGateway = fake_send
+
+    loop = asyncio.get_running_loop()
+    fut1 = loop.create_future()
+    fut2 = loop.create_future()
+    await selve.txQ.put((ServicePing(), fut1))
+    await selve.txQ.put((ServicePing(), fut2))
+
+    task = asyncio.create_task(selve._tx_loop())
+    try:
+        await asyncio.sleep(0.15)
+        # only the first command may have been sent so far
+        assert len(send_times) == 1
+        fut1.set_result("pong")
+        await asyncio.sleep(0.1)
+        assert len(send_times) == 2
+    finally:
+        selve._stopThread.set()
+        task.cancel()
+        try:
+            await task
+        except asyncio.CancelledError:
+            pass
+
+
+class TestDeviceCallbacks:
+    def test_callback_receives_device(self):
+        selve = _make_selve()
+        received = []
+        selve.register_callback(lambda device: received.append(device))
+
+        sentinel = object()
+        selve._fire_callbacks(sentinel)
+        assert received == [sentinel]
+
+    def test_zero_arg_callback_still_works(self):
+        selve = _make_selve()
+        calls = []
+
+        def legacy_callback():
+            calls.append(1)
+
+        selve.register_callback(legacy_callback)
+        selve._fire_callbacks(object())
+        assert calls == [1]
+
+    def test_failing_callback_does_not_break_others(self):
+        selve = _make_selve()
+        received = []
+
+        def bad_callback(device):
+            raise RuntimeError("boom")
+
+        selve.register_callback(bad_callback)
+        selve.register_callback(lambda device: received.append(device))
+        selve._fire_callbacks("dev")
+        assert received == ["dev"]
+
+    def test_remove_callback(self):
+        selve = _make_selve()
+        cb = lambda device: None
+        selve.register_callback(cb)
+        selve.remove_callback(cb)
+        assert cb not in selve._callbacks
+
+    def test_add_or_update_device_fires_callback_with_device(self):
+        selve = _make_selve()
+        received = []
+        selve.register_callback(lambda device: received.append(device))
+
+        dev = Mock()
+        dev.id = 7
+        selve.addOrUpdateDevice(dev, SelveTypes.DEVICE)
+        assert received == [dev]
+        assert selve.devices[SelveTypes.DEVICE.value][7] is dev
+
+
+@pytest.mark.asyncio
+async def test_update_all_devices_iterates_device_objects():
+    selve = _make_selve()
+    dev = Mock()
+    dev.id = 3
+    selve.devices[SelveTypes.DEVICE.value][3] = dev
+
+    selve.updateCommeoDeviceValues = AsyncMock()
+    selve.updateSensorValuesAsync = AsyncMock()
+    selve.updateSenSimValuesAsync = AsyncMock()
+    selve.updateSenderValuesAsync = AsyncMock()
+
+    await selve.updateAllDevices()
+    selve.updateCommeoDeviceValues.assert_awaited_once_with(3)

{python_selve_new-2.5.11 → python_selve_new-2.5.12}/tests/unit/test_selve_advanced_coverage.py

@@ -58,7 +58,7 @@ class TestSelveAdvancedCoverage(unittest.TestCase):
         gateway = Selve(logger=self.mock_logger)
         
         # Test that error callbacks are properly initialized
-        self.assertIsInstance(gateway._callbacks, set)
+        self.assertIsInstance(gateway._callbacks, dict)
         self.assertIsInstance(gateway._eventCallbacks, set)
         
         # Test device container structure

{python_selve_new-2.5.11 → python_selve_new-2.5.12}/tests/unit/test_selve_core_coverage.py

@@ -99,7 +99,7 @@ class TestSelveCoreClasses(unittest.TestCase):
         self.assertEqual(len(gateway._callbacks), 0)
         self.assertEqual(len(gateway._eventCallbacks), 0)
 
-        self.assertIsInstance(gateway._callbacks, set)
+        self.assertIsInstance(gateway._callbacks, dict)
         self.assertIsInstance(gateway._eventCallbacks, set)
 
     def test_state_properties(self):

{python_selve_new-2.5.11 → python_selve_new-2.5.12}/tests/unit/test_selve_edge_cases.py

@@ -176,7 +176,7 @@ class TestSelveEdgeCases:
         # Check data structures - txQ might be None initially
         assert selve.txQ is None or isinstance(selve.txQ, list)
         assert isinstance(selve.devices, dict)
-        assert isinstance(selve._callbacks, set)
+        assert isinstance(selve._callbacks, dict)
         assert isinstance(selve._eventCallbacks, set)
         
     def test_serial_attribute_handling(self):

{python_selve_new-2.5.11 → python_selve_new-2.5.12}/tests/unit/test_selve_init_comprehensive.py

@@ -47,7 +47,7 @@ class TestSelveInit:
         assert selve._port == "COM5"
         assert selve._LOGGER == logger
         assert selve.loop == loop
-        assert isinstance(selve._callbacks, set)
+        assert isinstance(selve._callbacks, dict)
         assert isinstance(selve._eventCallbacks, set)
         assert selve.utilization == 0
         assert selve.sendingBlocked == DutyMode.NOT_BLOCKED
@@ -63,7 +63,7 @@ class TestSelveInit:
         import logging
         assert isinstance(selve._LOGGER, logging.Logger)
         assert selve.loop is None
-        assert isinstance(selve._callbacks, set)
+        assert isinstance(selve._callbacks, dict)
         assert isinstance(selve._eventCallbacks, set)
 
     def test_init_devices_structure(self):

{python_selve_new-2.5.11 → python_selve_new-2.5.12}/tests/unit/test_selve_init_simple.py

@@ -18,7 +18,7 @@ class TestSelveInitSimple:
         """Test basic Selve initialization"""
         selve = Selve(port=None, discover=False, develop=False, logger=Mock())
         assert selve._port is None
-        assert selve._callbacks == set()
+        assert selve._callbacks == {}
         assert selve._eventCallbacks == set()
         assert selve.utilization == 0
         assert len(selve.devices) == 6