python-selve-new 2.5.1__tar.gz → 2.5.2__tar.gz

python_selve_new-2.5.2/.github/workflows/python-publish.yml

@@ -0,0 +1,45 @@
+# Publishes to PyPI after the "Run Tests" workflow succeeds on a version tag.
+
+name: Publish Python Package
+
+on:
+  workflow_run:
+    workflows: ["Run Tests"]
+    types: [completed]
+
+permissions:
+  contents: read
+
+jobs:
+  deploy:
+    runs-on: ubuntu-latest
+    # Only publish when tests passed AND the trigger was a version tag (e.g. v2.5.2)
+    if: |
+      github.event.workflow_run.conclusion == 'success' &&
+      startsWith(github.event.workflow_run.head_branch, 'v')
+
+    steps:
+    - uses: actions/checkout@v4
+      with:
+        fetch-depth: 0  # Fetch all history for setuptools_scm
+        ref: ${{ github.event.workflow_run.head_sha }}
+
+    - name: Set up Python
+      uses: actions/setup-python@v5
+      with:
+        python-version: '3.x'
+
+    - name: Install build dependencies
+      run: |
+        python -m pip install --upgrade pip
+        pip install build setuptools-scm
+
+    - name: Build package
+      run: |
+        python -m build
+
+    - name: Publish package to PyPI
+      uses: pypa/gh-action-pypi-publish@27b31702a0e7fc50959f5ad993c78deac1bdfc29
+      with:
+        user: __token__
+        password: ${{ secrets.PYPI_API_TOKEN }}

{python_selve_new-2.5.1 → python_selve_new-2.5.2}/.github/workflows/tests.yml

@@ -15,7 +15,7 @@ jobs:
     runs-on: ubuntu-latest
     strategy:
       matrix:
-        python-version: ['3.9', '3.10', '3.11', '3.12', '3.13']
+        python-version: ['3.10', '3.11', '3.12', '3.13']
     
     steps:
     - uses: actions/checkout@v4
@@ -48,7 +48,7 @@ jobs:
     
     - name: Run integration tests (without hardware)
       run: |
-        pytest tests/integration/ -v -m "not hardware" --timeout=30
+        pytest tests/integration/ -v -m "not hardware" --timeout=30 --ignore=tests/integration/test_selve_hardware.py
     
     - name: Generate coverage report (Python 3.11 only)
       if: matrix.python-version == '3.11'

{python_selve_new-2.5.1 → python_selve_new-2.5.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: python-selve-new
-Version: 2.5.1
+Version: 2.5.2
 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
@@ -21,7 +21,7 @@ Requires-Python: >=3.9
 Description-Content-Type: text/markdown
 License-File: LICENSE
 Requires-Dist: requests
-Requires-Dist: pyserial
+Requires-Dist: serialx
 Requires-Dist: pybase64
 Requires-Dist: untangle
 Requires-Dist: nest_asyncio

{python_selve_new-2.5.1 → python_selve_new-2.5.2}/pyproject.toml

@@ -31,7 +31,7 @@ classifiers = [
 ]
 dependencies = [
     "requests",
-    "pyserial",
+    "serialx",
     "pybase64",
     "untangle",
     "nest_asyncio",

{python_selve_new-2.5.1 → python_selve_new-2.5.2}/python_selve_new.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: python-selve-new
-Version: 2.5.1
+Version: 2.5.2
 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
@@ -21,7 +21,7 @@ Requires-Python: >=3.9
 Description-Content-Type: text/markdown
 License-File: LICENSE
 Requires-Dist: requests
-Requires-Dist: pyserial
+Requires-Dist: serialx
 Requires-Dist: pybase64
 Requires-Dist: untangle
 Requires-Dist: nest_asyncio

{python_selve_new-2.5.1 → python_selve_new-2.5.2}/python_selve_new.egg-info/requires.txt

@@ -1,5 +1,5 @@
 requests
-pyserial
+serialx
 pybase64
 untangle
 nest_asyncio

{python_selve_new-2.5.1 → python_selve_new-2.5.2}/selve/__init__.py

@@ -12,15 +12,19 @@ except ImportError:
         __version__ = "unknown"
 
 import asyncio
-import threading
 import time
 from collections import deque
 from itertools import chain
 from typing import Callable, Optional
 
-import serial
-from serial.tools import list_ports
-from serial import SerialException
+try:
+    from serial.tools import list_ports as _serial_list_ports
+    def _comports():
+        return _serial_list_ports.comports()
+except ImportError:
+    def _comports():  # type: ignore[misc]
+        return []
+
 import untangle
 
 from selve.commands import param, service
@@ -113,21 +117,21 @@ class Selve:
         # Kept for backward compatibility in tests/mocks.
         return True
 
-    def _build_transport(self, port: str):
+    async def _build_transport(self, port: str):
         self._transport = SerialTransport(port=port, logger=self._LOGGER)
-        self._transport.ensure_open()
-        self._serial = self._transport.serial
+        await self._transport.ensure_open()
+        self._serial = None
 
-    def _teardown_transport(self):
+    async def _teardown_transport(self):
         if self._transport:
-            self._transport.shutdown()
+            await self._transport.shutdown()
         self._transport = None
         self._serial = None
 
     async def _probe_port(self, port: str, fromConfigFlow: bool = False) -> bool:
         """Attempt to connect and verify a Selve gateway on the given port."""
         try:
-            self._build_transport(port)
+            await self._build_transport(port)
             ok = await self.pingGateway(fromConfigFlow=fromConfigFlow)
             if ok:
                 try:
@@ -142,13 +146,12 @@ class Selve:
             self._LOGGER.debug(f"Probe failed on {port}: {e}")
 
         await self.stopWorker()
-        self._teardown_transport()
+        await self._teardown_transport()
         return False
     
 
     def list_ports(self):
-        available_ports = list_ports.comports()
-        return available_ports
+        return _comports()
 
     async def check_port(self, port):
         if port is not None:
@@ -172,22 +175,14 @@ class Selve:
                             await self.discover()
                         await self.startWorker()
                     return
-            except (serial.SerialException, IOError) as e:
+            except (OSError, IOError) as e:
                 self._LOGGER.debug("Configured port not valid! " + str(e))
             except Exception as e:
                 self._LOGGER.error("Unknown exception: " + str(e))
 
 
-        if self.loop is not None:
-            # Use the current running loop to avoid "different loop" errors
-            try:
-                current_loop = asyncio.get_running_loop()
-                available_ports = await current_loop.run_in_executor(None, list_ports.comports)
-            except RuntimeError:
-                # No running loop, use the instance loop
-                available_ports = await self.loop.run_in_executor(None, list_ports.comports)
-        else:
-            available_ports = list_ports.comports()
+        loop = asyncio.get_running_loop()
+        available_ports = await loop.run_in_executor(None, _comports)
         
         self._LOGGER.debug("available comports: " + str(available_ports))
 
@@ -216,31 +211,22 @@ class Selve:
         await asyncio.sleep(5)
         self._LOGGER.debug("(Selve Worker): " + "Recovering")
 
-        self._teardown_transport()
+        await self._teardown_transport()
 
         if self._port is not None:
             try:
                 if await self._probe_port(self._port, fromConfigFlow=False):
                     if self.rxQ is not None and self._transport is not None:
-                        loop = self.loop or asyncio.get_running_loop()
-                        self._transport.start_reader(loop, self.rxQ)
+                        await self._transport.start_reader(self.rxQ)
                     return
-            except (serial.SerialException, IOError) as e:
+            except (OSError, IOError) as e:
                 self._LOGGER.debug("(Selve Worker): " + "Configured port not valid, maybe it has changed, trying other ports...")
             except Exception as e:
                 self._LOGGER.error("(Selve Worker): " + "Unknown exception: " + str(e))
 
-        if self.loop is not None:
-            # Use the current running loop to avoid "different loop" errors
-            try:
-                current_loop = asyncio.get_running_loop()
-                available_ports = await current_loop.run_in_executor(None, list_ports.comports)
-            except RuntimeError:
-                # No running loop, use the instance loop
-                available_ports = await self.loop.run_in_executor(None, list_ports.comports)
-        else:
-            available_ports = list_ports.comports()
-        
+        loop = asyncio.get_running_loop()
+        available_ports = await loop.run_in_executor(None, _comports)
+
         self._LOGGER.debug("(Selve Worker): " + "available comports: " + str(available_ports))
 
         if len(available_ports) == 0:
@@ -251,8 +237,7 @@ class Selve:
             try:
                 if await self._probe_port(p.device, fromConfigFlow=False):
                     if self.rxQ is not None and self._transport is not None:
-                        loop = self.loop or asyncio.get_running_loop()
-                        self._transport.start_reader(loop, self.rxQ)
+                        await self._transport.start_reader(self.rxQ)
                     return
             except Exception as e:
                 self._LOGGER.error("(Selve Worker): " + "Error at com port: " + str(e))
@@ -273,12 +258,11 @@ class Selve:
         if self._event_queue is None or not isinstance(self._event_queue, asyncio.Queue):
             self._event_queue = asyncio.Queue()
 
-        # Ensure transport and reader thread are running
-        loop = self.loop or asyncio.get_running_loop()
+        # Ensure transport and reader task are running
         if self._transport is None and self._port is not None:
-            self._build_transport(self._port)
+            await self._build_transport(self._port)
         if self._transport is not None:
-            self._transport.start_reader(loop, self.rxQ)
+            await self._transport.start_reader(self.rxQ)
 
         if self._tx_task is None or self._tx_task.done():
             self._tx_task = asyncio.create_task(self._tx_loop())
@@ -371,7 +355,7 @@ class Selve:
         self._dispatch_task = None
         self._pending_futures.clear()
         if self._transport:
-            self._transport.stop_reader()
+            await self._transport.stop_reader()
         if self._event_queue is not None:
             while not self._event_queue.empty():
                 try:
@@ -387,7 +371,7 @@ class Selve:
         self._LOGGER.debug("Preparing for termination")
         await self.stopWorker()
         # close the serial port, do the cleanup
-        self._teardown_transport()
+        await self._teardown_transport()
         return True
 
 
@@ -428,20 +412,20 @@ class Selve:
             if self._transport is None:
                 if self._port is None:
                     raise PortError("No serial port configured")
-                self._build_transport(self._port)
+                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 (serial.SerialException, IOError) as se:
+        except (OSError, IOError) as se:
             self._LOGGER.info('Serial error, trying to reconnect once... ' + str(se))
             await self.recover()
 
             try:
                 self._LOGGER.debug('Trying again...')
                 if self._transport is None and self._port is not None:
-                    self._build_transport(self._port)
+                    await self._build_transport(self._port)
                 await self._transport.write(commandstr)
                 await asyncio.sleep(0.1)
             
@@ -1188,7 +1172,8 @@ class Selve:
         while await self.gatewayState() != ServiceState.READY:
             if time.time() - start_time >= 30:
                 self._LOGGER.info("Error: Gateway could not be reset or loads too long")
-            pass
+                break
+            await asyncio.sleep(0.1)
         self._LOGGER.info("Gateway reset")
 
     async def factoryResetGateway(self):
@@ -1201,7 +1186,8 @@ class Selve:
         while await self.gatewayState() != ServiceState.READY:
             if time.time() - start_time >= 60:
                 self._LOGGER.info("Error: Gateway could not be reset or loads too long")
-            pass
+                break
+            await asyncio.sleep(0.1)
         self._LOGGER.info("Gateway factory reset")
         return response.executed
 

python_selve_new-2.5.2/selve/_version.py

@@ -0,0 +1,24 @@
+# file generated by vcs-versioning
+# don't change, don't track in version control
+from __future__ import annotations
+
+__all__ = [
+    "__version__",
+    "__version_tuple__",
+    "version",
+    "version_tuple",
+    "__commit_id__",
+    "commit_id",
+]
+
+version: str
+__version__: str
+__version_tuple__: tuple[int | str, ...]
+version_tuple: tuple[int | str, ...]
+commit_id: str | None
+__commit_id__: str | None
+
+__version__ = version = '2.5.2'
+__version_tuple__ = version_tuple = (2, 5, 2)
+
+__commit_id__ = commit_id = 'g24c865c13'

python_selve_new-2.5.2/selve/util/serial_transport.py

@@ -0,0 +1,121 @@
+import asyncio
+import logging
+from typing import Optional
+
+import serialx
+from serialx import Parity
+
+
+class SerialTransport:
+    """Async serial transport using serialx (replaces pyserial + background thread)."""
+
+    def __init__(
+        self,
+        port: str,
+        baudrate: int = 115200,
+        read_timeout: float = 1.0,
+        logger: Optional[logging.Logger] = None,
+    ) -> None:
+        self._port = port
+        self._baudrate = baudrate
+        self._read_timeout = read_timeout
+        self._logger = logger or logging.getLogger(__name__)
+
+        self._reader: Optional[asyncio.StreamReader] = None
+        self._writer: Optional[asyncio.StreamWriter] = None
+        self._reader_task: Optional[asyncio.Task] = None
+        self._rx_queue: Optional[asyncio.Queue] = None
+
+    @property
+    def port(self) -> str:
+        return self._port
+
+    @property
+    def is_open(self) -> bool:
+        return self._writer is not None and not self._writer.is_closing()
+
+    async def ensure_open(self) -> None:
+        if not self.is_open:
+            self._reader, self._writer = await serialx.open_serial_connection(
+                url=self._port,
+                baudrate=self._baudrate,
+                bytesize=8,
+                parity=Parity.NONE,
+                stopbits=1,
+                xonxoff=False,
+                rtscts=False,
+                dsrdtr=False,
+            )
+
+    async def close(self) -> None:
+        try:
+            if self._writer and not self._writer.is_closing():
+                self._writer.close()
+                await self._writer.wait_closed()
+        except Exception:
+            self._logger.debug("Serial close failed", exc_info=True)
+        self._reader = None
+        self._writer = None
+
+    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():
+            return
+        self._reader_task = asyncio.create_task(
+            self._reader_loop(), name="selve-serial-reader"
+        )
+
+    async def stop_reader(self) -> None:
+        if self._reader_task:
+            self._reader_task.cancel()
+            try:
+                await self._reader_task
+            except asyncio.CancelledError:
+                pass
+            self._reader_task = None
+
+    async def _reader_loop(self) -> None:
+        buffer = ""
+        while True:
+            try:
+                if self._reader is None:
+                    await self.ensure_open()
+                line_bytes = await self._reader.readline()
+            except asyncio.CancelledError:
+                break
+            except (OSError, EOFError) as exc:
+                self._logger.error("Serial read error: %s", exc)
+                await asyncio.sleep(1)
+                continue
+            except Exception:
+                self._logger.error("Unexpected serial read error", exc_info=True)
+                await asyncio.sleep(1)
+                continue
+
+            if not line_bytes:
+                await asyncio.sleep(0.01)
+                continue
+
+            decoded = line_bytes.decode(errors="ignore").strip()
+            if decoded == "":
+                if buffer and self._rx_queue:
+                    await self._rx_queue.put(buffer)
+                    buffer = ""
+                continue
+
+            buffer += decoded
+
+    async def write(self, payload: bytes) -> None:
+        await self.ensure_open()
+        try:
+            self._writer.write(payload)
+            await self._writer.drain()
+        except OSError as exc:
+            self._logger.error("Serial write error: %s", exc)
+            raise
+
+    async def shutdown(self) -> None:
+        await self.stop_reader()
+        await self.close()

{python_selve_new-2.5.1 → python_selve_new-2.5.2}/setup.py

@@ -39,7 +39,6 @@ setup(
         # Specify the Python versions you support here. In particular, ensure
         # that you indicate whether you support Python 2, Python 3 or both.
         'Programming Language :: Python :: 3',
-        'Programming Language :: Python :: 3.9',
         'Programming Language :: Python :: 3.10',
         'Programming Language :: Python :: 3.11',
         'Programming Language :: Python :: 3.12'
@@ -56,7 +55,7 @@ setup(
     # For an analysis of "install_requires" vs pip's requirements files see:
     # https://packaging.python.org/en/latest/requirements.html
     install_requires=[
-        'pyserial',
+        'serialx',
         'pybase64',
         'untangle',
         'nest_asyncio',

{python_selve_new-2.5.1 → python_selve_new-2.5.2}/tests/conftest.py

@@ -3,7 +3,19 @@ import logging
 import sys
 import asyncio
 import nest_asyncio
-from unittest.mock import MagicMock, patch
+from unittest.mock import MagicMock, AsyncMock, patch
+
+# Stub out serialx before any selve import so the protobuf/aioesphomeapi
+# version conflict in serialx's optional esphome platform never fires.
+_serialx_mock = MagicMock()
+_serialx_mock.Parity = MagicMock()
+_serialx_mock.Parity.NONE = "N"
+_serialx_mock.open_serial_connection = AsyncMock(
+    return_value=(MagicMock(), MagicMock())
+)
+sys.modules.setdefault("serialx", _serialx_mock)
+sys.modules.setdefault("serialx.platforms", MagicMock())
+sys.modules.setdefault("serialx.platforms.serial_esphome", MagicMock())
 
 # Ermöglicht das Ausführen von async-Funktionen in einem bereits laufenden Event-Loop
 # Dies ist wichtig für die Integration-Tests
@@ -34,19 +46,23 @@ def logger():
 
 @pytest.fixture
 def mock_serial():
-    """Mock the serial port for testing."""
-    with patch('selve.serial.Serial') as mock:
+    """Mock the SerialTransport for testing."""
+    with patch('selve.util.serial_transport.SerialTransport') as mock:
         mock_instance = MagicMock()
         mock.return_value = mock_instance
         mock_instance.is_open = True
-        mock_instance.read_until.return_value = b'<methodResponse name="selve.GW.service.ping"></methodResponse>'
+        mock_instance.ensure_open = AsyncMock()
+        mock_instance.start_reader = AsyncMock()
+        mock_instance.stop_reader = AsyncMock()
+        mock_instance.write = AsyncMock()
+        mock_instance.shutdown = AsyncMock()
         yield mock
 
 
 @pytest.fixture
 def mock_list_ports():
-    """Mock the list_ports.comports function."""
-    with patch('selve.list_ports.comports') as mock:
+    """Mock the _comports function."""
+    with patch('selve._comports') as mock:
         # Create a mock port
         mock_port = MagicMock()
         mock_port.device = "COM3"

{python_selve_new-2.5.1 → python_selve_new-2.5.2}/tests/integration/conftest.py

@@ -39,17 +39,17 @@ def event_loop():
 
 @pytest.fixture
 def mock_serial():
-    """Provide a mocked serial interface."""
-    with patch('selve.serial.Serial') as mock_serial:
-        # Configure mock serial port
-        mock_serial_instance = mock_serial.return_value
-        mock_serial_instance.is_open = True
-        mock_serial_instance.read_until.return_value = b'<methodResponse name="selve.GW.service.ping"></methodResponse>'
-        mock_serial_instance.write = MagicMock()
-        mock_serial_instance.in_waiting = 0
-        mock_serial_instance.readline = MagicMock(return_value=b'<methodResponse name="selve.GW.command.result" result="true"></methodResponse>')
-        
-        yield mock_serial
+    """Provide a mocked serial transport."""
+    with patch('selve.util.serial_transport.SerialTransport') as mock_transport:
+        mock_instance = mock_transport.return_value
+        mock_instance.is_open = True
+        mock_instance.ensure_open = AsyncMock()
+        mock_instance.start_reader = AsyncMock()
+        mock_instance.stop_reader = AsyncMock()
+        mock_instance.write = AsyncMock()
+        mock_instance.shutdown = AsyncMock()
+
+        yield mock_transport
 
 
 @pytest.fixture

{python_selve_new-2.5.1 → python_selve_new-2.5.2}/tests/integration/test_device_integration.py

@@ -3,7 +3,6 @@ import logging
 import sys
 import asyncio
 import os
-import serial
 from unittest.mock import MagicMock, patch, AsyncMock
 
 # Import the Selve package
@@ -38,16 +37,17 @@ class TestDeviceIntegration(unittest.TestCase):
 
     def setUp(self):
         """Set up mock serial port and other mocks."""
-        self.mock_serial_patcher = patch('selve.serial.Serial')
+        self.mock_serial_patcher = patch('selve.util.serial_transport.SerialTransport')
         self.mock_serial = self.mock_serial_patcher.start()
-        
-        # Configure mock serial port
-        mock_serial_instance = self.mock_serial.return_value
-        mock_serial_instance.is_open = True
-        mock_serial_instance.read_until.return_value = b'<methodResponse name="selve.GW.service.ping"></methodResponse>'
-        mock_serial_instance.write = MagicMock()
-        mock_serial_instance.in_waiting = 0
-        mock_serial_instance.readline = MagicMock(return_value=b'<methodResponse name="selve.GW.command.result" result="true"></methodResponse>')
+
+        # Configure mock transport
+        mock_transport_instance = self.mock_serial.return_value
+        mock_transport_instance.is_open = True
+        mock_transport_instance.ensure_open = AsyncMock()
+        mock_transport_instance.start_reader = AsyncMock()
+        mock_transport_instance.stop_reader = AsyncMock()
+        mock_transport_instance.write = AsyncMock()
+        mock_transport_instance.shutdown = AsyncMock()
         
         # Create the Selve instance
         self.selve = Selve(port="COM3", discover=False, develop=True, 
@@ -241,7 +241,7 @@ class TestDeviceIntegration(unittest.TestCase):
     def test_connection_error_handling(self):
         """Test handling of connection errors in device commands."""
         # Make executeCommandSyncWithResponse raise an exception
-        self.selve.executeCommandSyncWithResponse.side_effect = serial.SerialException("Connection failed")
+        self.selve.executeCommandSyncWithResponse.side_effect = OSError("Connection failed")
         
         # Setup the test
         async def test_async():
@@ -250,7 +250,7 @@ class TestDeviceIntegration(unittest.TestCase):
                 result = await self.selve.moveDeviceUp(self.device)
                 # The method should have caught the exception and returned False
                 self.assertFalse(result, "Method should return False on serial exception")
-            except serial.SerialException:
+            except OSError:
                 # If the exception wasn't caught, we need to patch the method
                 from unittest.mock import patch
                 

{python_selve_new-2.5.1 → python_selve_new-2.5.2}/tests/integration/test_selve_gateway_integration.py

@@ -42,9 +42,6 @@ class TestSelveGatewayIntegration:
             
             # Verify port was set correctly
             assert selve._port == "COM3"
-            
-            # Verify serial was initialized
-            assert selve._serial is not None
     
     @pytest.mark.asyncio
     async def test_gateway_setup_with_invalid_port(self, mock_serial, logger):
@@ -85,14 +82,8 @@ class TestSelveGatewayIntegration:
         # Directly test the recover method with mocked components
         with patch.object(mock_selve_instance, '_LOGGER') as mock_logger:
             with patch('asyncio.sleep', return_value=None):  # Skip the sleep delay
-                with patch('selve.serial.Serial') as mock_serial_class:
-                    # Configure the mock serial to succeed
-                    mock_serial_instance = MagicMock()
-                    mock_serial_instance.is_open = True
-                    mock_serial_class.return_value = mock_serial_instance
-                    
-                    # Mock _probe_port to return True immediately
-                    mock_selve_instance._probe_port = AsyncMock(return_value=True)
+                # Mock _probe_port to return True immediately
+                with patch.object(mock_selve_instance, '_probe_port', AsyncMock(return_value=True)):
                     mock_selve_instance._port = "COM3"
                     
                     # Call recover directly