Client coverage 100%. (#1943)

Author: janiversen

pymodbus/client/base.py

@@ -163,7 +163,7 @@ async def async_execute(self, request=None):
                 resp = b"Broadcast write sent - no response expected"
                 break
             try:
-                req = self._build_response(request.transaction_id)
+                req = self.build_response(request.transaction_id)
                 resp = await asyncio.wait_for(
                     req, timeout=self.comm_params.timeout_connect
                 )
@@ -186,14 +186,6 @@ def callback_data(self, data: bytes, addr: tuple | None = None) -> int:
         self.framer.processIncomingPacket(data, self._handle_response, slave=0)
         return len(data)
 
-    def callback_disconnected(self, _reason: Exception | None) -> None:
-        """Handle lost connection."""
-        for tid in list(self.transaction):
-            self.raise_future(
-                self.transaction.getTransaction(tid),
-                ConnectionException("Connection lost during request"),
-            )
-
     async def connect(self):
         """Connect to the modbus remote host."""
 
@@ -212,7 +204,7 @@ def _handle_response(self, reply, **_kwargs):
             else:
                 Log.debug("Unrequested message: {}", reply, ":str")
 
-    def _build_response(self, tid):
+    def build_response(self, tid):
         """Return a deferred response for the current request."""
         my_future = asyncio.Future()
         if not self.transport:
@@ -229,26 +221,12 @@ def send(self, request):
 
         :meta private:
         """
-        if self.state != ModbusTransactionState.RETRYING:
-            Log.debug('New Transaction state "SENDING"')
-            self.state = ModbusTransactionState.SENDING
-        return request
 
     def recv(self, size):
         """Receive data.
 
         :meta private:
         """
-        return size
-
-    @classmethod
-    def _get_address_family(cls, address):
-        """Get the correct address family."""
-        try:
-            _ = socket.inet_pton(socket.AF_INET6, address)
-        except OSError:  # not a valid ipv6 address
-            return socket.AF_INET
-        return socket.AF_INET6
 
     # ----------------------------------------------------------------------- #
     # The magic methods
@@ -259,8 +237,7 @@ def __enter__(self):
         :returns: The current instance of the client
         :raises ConnectionException:
         """
-        if not self.connect():
-            raise ConnectionException(f"Failed to connect[{self.__str__()}]")
+        self.connect()
         return self
 
     async def __aenter__(self):
@@ -269,8 +246,7 @@ async def __aenter__(self):
         :returns: The current instance of the client
         :raises ConnectionException:
         """
-        if not await self.connect():
-            raise ConnectionException(f"Failed to connect[{self.__str__()}]")
+        await self.connect()
         return self
 
     def __exit__(self, klass, value, traceback):
@@ -400,11 +376,6 @@ def __init__(  # pylint: disable=too-many-arguments
     # ----------------------------------------------------------------------- #
     # Client external interface
     # ----------------------------------------------------------------------- #
-    @property
-    def connected(self) -> bool:
-        """Return state of connection."""
-        return self.is_active()
-
     def register(self, custom_response_class: ModbusResponse) -> None:
         """Register a custom response class with the decoder (call **sync**).
 
@@ -416,13 +387,6 @@ def register(self, custom_response_class: ModbusResponse) -> None:
         """
         self.framer.decoder.register(custom_response_class)
 
-    def close(self, reconnect: bool = False) -> None:
-        """Close connection."""
-        if reconnect:
-            self.connection_lost(asyncio.TimeoutError("Server not responding"))
-        else:
-            self.transport_close()
-
     def idle_time(self) -> float:
         """Time before initiating next transaction (call **sync**).
 
@@ -444,80 +408,6 @@ def execute(self, request: ModbusRequest | None = None) -> ModbusResponse:
             raise ConnectionException(f"Failed to connect[{self!s}]")
         return self.transaction.execute(request)
 
-    # ----------------------------------------------------------------------- #
-    # Merged client methods
-    # ----------------------------------------------------------------------- #
-    async def async_execute(self, request=None):
-        """Execute requests asynchronously."""
-        request.transaction_id = self.transaction.getNextTID()
-        packet = self.framer.buildPacket(request)
-
-        count = 0
-        while count <= self.params.retries:
-            if not count or not self.no_resend_on_retry:
-                self.transport_send(packet)
-            if self.params.broadcast_enable and not request.slave_id:
-                resp = b"Broadcast write sent - no response expected"
-                break
-            try:
-                req = self._build_response(request.transaction_id)
-                resp = await asyncio.wait_for(
-                    req, timeout=self.comm_params.timeout_connect
-                )
-                break
-            except asyncio.exceptions.TimeoutError:
-                count += 1
-        if count > self.params.retries:
-            self.close(reconnect=True)
-            raise ModbusIOException(
-                f"ERROR: No response received after {self.params.retries} retries"
-            )
-
-        return resp
-
-    def callback_data(self, data: bytes, addr: tuple | None = None) -> int:
-        """Handle received data.
-
-        returns number of bytes consumed
-        """
-        self.framer.processIncomingPacket(data, self._handle_response, slave=0)
-        return len(data)
-
-    def callback_disconnected(self, _reason: Exception | None) -> None:
-        """Handle lost connection."""
-        for tid in list(self.transaction):
-            self.raise_future(
-                self.transaction.getTransaction(tid),
-                ConnectionException("Connection lost during request"),
-            )
-
-    async def connect(self):
-        """Connect to the modbus remote host."""
-
-    def raise_future(self, my_future, exc):
-        """Set exception of a future if not done."""
-        if not my_future.done():
-            my_future.set_exception(exc)
-
-    def _handle_response(self, reply, **_kwargs):
-        """Handle the processed response and link to correct deferred."""
-        if reply is not None:
-            tid = reply.transaction_id
-            if handler := self.transaction.getTransaction(tid):
-                if not handler.done():
-                    handler.set_result(reply)
-            else:
-                Log.debug("Unrequested message: {}", reply, ":str")
-
-    def _build_response(self, tid):
-        """Return a deferred response for the current request."""
-        my_future = asyncio.Future()
-        if not self.transport:
-            self.raise_future(my_future, ConnectionException("Client is not connected"))
-        else:
-            self.transaction.addTransaction(my_future, tid)
-        return my_future
-
     # ----------------------------------------------------------------------- #
     # Internal methods
     # ----------------------------------------------------------------------- #
@@ -539,14 +429,20 @@ def recv(self, size):
         return size
 
     @classmethod
-    def _get_address_family(cls, address):
+    def get_address_family(cls, address):
         """Get the correct address family."""
         try:
             _ = socket.inet_pton(socket.AF_INET6, address)
         except OSError:  # not a valid ipv6 address
             return socket.AF_INET
         return socket.AF_INET6
 
+    def connect(self):
+        """Connect to other end, overwritten."""
+
+    def close(self):
+        """Close connection, overwritten."""
+
     # ----------------------------------------------------------------------- #
     # The magic methods
     # ----------------------------------------------------------------------- #
@@ -556,28 +452,13 @@ def __enter__(self):
         :returns: The current instance of the client
         :raises ConnectionException:
         """
-        if not self.connect():
-            raise ConnectionException(f"Failed to connect[{self.__str__()}]")
-        return self
-
-    async def __aenter__(self):
-        """Implement the client with enter block.
-
-        :returns: The current instance of the client
-        :raises ConnectionException:
-        """
-        if not await self.connect():
-            raise ConnectionException(f"Failed to connect[{self.__str__()}]")
+        self.connect()
         return self
 
     def __exit__(self, klass, value, traceback):
         """Implement the client with exit block."""
         self.close()
 
-    async def __aexit__(self, klass, value, traceback):
-        """Implement the client with exit block."""
-        self.close()
-
     def __str__(self):
         """Build a string representation of the connection.
 

pymodbus/client/mixin.py

@@ -14,7 +14,6 @@
 import pymodbus.other_message as pdu_other_msg
 import pymodbus.register_read_message as pdu_reg_read
 import pymodbus.register_write_message as pdu_req_write
-from pymodbus.constants import INTERNAL_ERROR
 from pymodbus.exceptions import ModbusException
 from pymodbus.pdu import ModbusRequest, ModbusResponse
 
@@ -49,19 +48,18 @@ def __init__(self):
         """Initialize."""
 
     def execute(
-        self, request: ModbusRequest
+        self, _request: ModbusRequest
     ) -> ModbusResponse | Awaitable[ModbusResponse]:
         """Execute request (code ???).
 
-        :param request: Request to send
         :raises ModbusException:
 
         Call with custom function codes.
 
         .. tip::
             Response is not interpreted.
         """
-        raise ModbusException(INTERNAL_ERROR)
+        return ModbusResponse()
 
     def read_coils(
         self, address: int, count: int = 1, slave: int = 0, **kwargs: Any

pymodbus/client/serial.py

@@ -198,7 +198,7 @@ def connected(self):
         """Connect internal."""
         return self.connect()
 
-    def connect(self):  # pylint: disable=invalid-overridden-method
+    def connect(self):
         """Connect to the modbus serial server."""
         if self.socket:
             return True
@@ -219,21 +219,15 @@ def connect(self):  # pylint: disable=invalid-overridden-method
             self.close()
         return self.socket is not None
 
-    def close(self):  # pylint: disable=arguments-differ
+    def close(self):
         """Close the underlying socket connection."""
         if self.socket:
             self.socket.close()
         self.socket = None
 
     def _in_waiting(self):
-        """Return _in_waiting."""
-        in_waiting = "in_waiting" if hasattr(self.socket, "in_waiting") else "inWaiting"
-
-        if in_waiting == "in_waiting":
-            waitingbytes = getattr(self.socket, in_waiting)
-        else:
-            waitingbytes = getattr(self.socket, in_waiting)()
-        return waitingbytes
+        """Return waiting bytes."""
+        return getattr(self.socket, "in_waiting") if hasattr(self.socket, "in_waiting") else getattr(self.socket, "inWaiting")()
 
     def send(self, request):
         """Send data on the underlying socket.
@@ -246,20 +240,9 @@ def send(self, request):
         if not self.socket:
             raise ConnectionException(str(self))
         if request:
-            try:
-                if waitingbytes := self._in_waiting():
-                    result = self.socket.read(waitingbytes)
-                    if self.state == ModbusTransactionState.RETRYING:
-                        Log.debug(
-                            "Sending available data in recv buffer {}", result, ":hex"
-                        )
-                        return result
-                    Log.warning("Cleanup recv buffer before send: {}", result, ":hex")
-            except NotImplementedError:
-                pass
-            if self.state != ModbusTransactionState.SENDING:
-                Log.debug('New Transaction state "SENDING"')
-                self.state = ModbusTransactionState.SENDING
+            if waitingbytes := self._in_waiting():
+                result = self.socket.read(waitingbytes)
+                Log.warning("Cleanup recv buffer before send: {}", result, ":hex")
             size = self.socket.write(request)
             return size
         return 0
@@ -268,16 +251,10 @@ def _wait_for_data(self):
         """Wait for data."""
         size = 0
         more_data = False
-        if (
-            self.comm_params.timeout_connect is not None
-            and self.comm_params.timeout_connect
-        ):
-            condition = partial(
-                lambda start, timeout: (time.time() - start) <= timeout,
-                timeout=self.comm_params.timeout_connect,
-            )
-        else:
-            condition = partial(lambda dummy1, dummy2: True, dummy2=None)
+        condition = partial(
+            lambda start, timeout: (time.time() - start) <= timeout,
+            timeout=self.comm_params.timeout_connect,
+        )
         start = time.time()
         while condition(start):
             available = self._in_waiting()
@@ -306,15 +283,9 @@ def recv(self, size):
     def is_socket_open(self):
         """Check if socket is open."""
         if self.socket:
-            if hasattr(self.socket, "is_open"):
-                return self.socket.is_open
-            return self.socket.isOpen()
+            return self.socket.is_open if hasattr(self.socket, "is_open") else self.socket.isOpen()
         return False
 
-    def __str__(self):
-        """Build a string representation of the connection."""
-        return f"ModbusSerialClient({self.framer} baud[{self.comm_params.baudrate}])"
-
     def __repr__(self):
         """Return string representation."""
         return (