Add connect/listen to transport with tests.

Author: janiversen

pymodbus/client/base.py

@@ -95,8 +95,16 @@ def __init__(  # pylint: disable=too-many-arguments
     ) -> None:
         """Initialize a client instance."""
         BaseTransport.__init__(
-            self, "comm", framer, reconnect_delay, reconnect_delay_max, timeout, timeout
+            self,
+            "comm",
+            (reconnect_delay, reconnect_delay_max),
+            timeout,
+            framer,
+            lambda: None,
+            self.cb_base_connection_lost,
+            self.cb_base_handle_data,
         )
+        self.framer = framer
         self.params = self._params()
         self.params.framer = framer
         self.params.timeout = float(timeout)
@@ -198,24 +206,16 @@ async def async_execute(self, request=None):
                 raise
         return resp
 
-    def data_received(self, data):
-        """Call when some data is received.
-
-        data is a non-empty bytes object containing the incoming data.
-        """
-        Log.debug("recv: {}", data, ":hex")
-        self.framer.processIncomingPacket(data, self._handle_response, slave=0)
-
-    def cb_handle_data(self, _data: bytes) -> int:
+    def cb_base_handle_data(self, data: bytes) -> int:
         """Handle received data
 
         returns number of bytes consumed
         """
+        Log.debug("recv: {}", data, ":hex")
+        self.framer.processIncomingPacket(data, self._handle_response, slave=0)
+        return len(data)
 
-    def cb_connection_made(self) -> None:
-        """Handle new connection"""
-
-    def cb_connection_lost(self, _reason: Exception) -> None:
+    def cb_base_connection_lost(self, _reason: Exception) -> None:
         """Handle lost connection"""
         for tid in list(self.transaction):
             self.raise_future(

pymodbus/client/serial.py

@@ -6,12 +6,12 @@
 from typing import Any, Type
 
 from pymodbus.client.base import ModbusBaseClient
-from pymodbus.client.serial_asyncio import create_serial_connection
 from pymodbus.constants import Defaults
 from pymodbus.exceptions import ConnectionException
 from pymodbus.framer import ModbusFramer
 from pymodbus.framer.rtu_framer import ModbusRtuFramer
 from pymodbus.logging import Log
+from pymodbus.transport.serial_asyncio import create_serial_connection
 from pymodbus.utilities import ModbusTransactionState
 
 
@@ -173,13 +173,12 @@ def __init__(
             else 0.05
         )
 
-        if isinstance(self.framer, ModbusRtuFramer):
-            if self.params.baudrate > 19200:
-                self.silent_interval = 1.75 / 1000  # ms
-            else:
-                self.inter_char_timeout = 1.5 * self._t0
-                self.silent_interval = 3.5 * self._t0
-            self.silent_interval = round(self.silent_interval, 6)
+        if self.params.baudrate > 19200:
+            self.silent_interval = 1.75 / 1000  # ms
+        else:
+            self.inter_char_timeout = 1.5 * self._t0
+            self.silent_interval = 3.5 * self._t0
+        self.silent_interval = round(self.silent_interval, 6)
 
     @property
     def connected(self):

pymodbus/server/async_io.py

@@ -7,7 +7,6 @@
 from contextlib import suppress
 from typing import Union
 
-from pymodbus.client.serial_asyncio import create_serial_connection
 from pymodbus.constants import Defaults
 from pymodbus.datastore import ModbusServerContext
 from pymodbus.device import ModbusControlBlock, ModbusDeviceIdentification
@@ -21,6 +20,7 @@
     ModbusSocketFramer,
     ModbusTlsFramer,
 )
+from pymodbus.transport.serial_asyncio import create_serial_connection
 
 
 with suppress(ImportError):

pymodbus/client/serial_asyncio/README.md renamed to pymodbus/transport/serial_asyncio/README.md

@@ -1,5 +1,4 @@
 #!/usr/bin/env python3
-# -*- coding: utf-8 -*-
 #
 # Implementation of asyncio support.
 #
@@ -16,12 +15,13 @@
 implementation. It should be possible to get that working though.
 """
 import asyncio
+import contextlib
 import os
 
-try:
+
+with contextlib.suppress(ImportError):
     import serial
-except ImportError:
-    pass
+
 
 try:
     import termios
@@ -41,7 +41,7 @@ class SerialTransport(asyncio.Transport):
     indeed a serial port.
 
 
-    You generally won’t instantiate a transport yourself; instead, you
+    You generally won`t instantiate a transport yourself; instead, you
     will call `create_serial_connection` which will create the
     transport and try to initiate the underlying communication channel,
     calling you back when it succeeds.
@@ -129,7 +129,8 @@ def write(self, data):
 
         This method does not block; it buffers the data and arranges
         for it to be sent out asynchronously.  Writes made after the
-        transport has been closed will be ignored."""
+        transport has been closed will be ignored.
+        """
         if self._closing:
             return
 
@@ -151,7 +152,7 @@ def can_write_eof(self):
     def pause_reading(self):
         """Pause the receiving end of the transport.
 
-        No data will be passed to the protocol’s data_received() method
+        No data will be passed to the protocol`s data_received() method
         until resume_reading() is called.
         """
         self._remove_reader()
@@ -167,7 +168,7 @@ def resume_reading(self):
     def set_write_buffer_limits(self, high=None, low=None):
         """Set the high- and low-water limits for write flow control.
 
-        These two values control when the protocol’s
+        These two values control when the protocol`s
         pause_writing()and resume_writing() methods are called. If
         specified, the low-water limit must be less than or equal to
         the high-water limit. Neither high nor low can be negative.
@@ -197,7 +198,7 @@ def abort(self):
         self._abort(None)
 
     def flush(self):
-        """clears output buffer and stops any more data being written"""
+        """Clears output buffer and stops any more data being written"""
         self._remove_writer()
         self._write_buffer.clear()
         self._maybe_resume_protocol()
@@ -361,7 +362,7 @@ def _set_write_buffer_limits(self, high=None, low=None):
         if low is None:
             low = high // 4
         if not high >= low >= 0:
-            raise ValueError("high (%r) must be >= low (%r) must be >= 0" % (high, low))
+            raise ValueError(f"high ({high!r}) must be >= low ({low!r}) must be >= 0")
         self._high_water = high
         self._low_water = low
 
@@ -423,19 +424,15 @@ def _call_connection_lost(self, exc):
         assert not self._has_writer
         assert not self._has_reader
         if self._serial:
-            try:
+            with contextlib.suppress(Exception):
                 self._serial.flush()
-            except serial.SerialException if os.name == "nt" else termios.error:
-                # ignore serial errors which may happen if the serial device was
-                # hot-unplugged.
-                pass
+
             self._serial.close()
             self._serial = None
         if self._protocol:
-            try:
+            with contextlib.suppress(Exception):
                 self._protocol.connection_lost(exc)
-            except:
-                pass
+
             self._write_buffer.clear()
         self._write_buffer.clear()
         self._loop = None