Client/Server decoder with typing.

doc/source/roadmap.rst

@@ -21,8 +21,7 @@ The following bullet points are what the maintainers focus on:
         - more typing in the core
         - 100% test coverage fixed for all new parts (currently transport and framer)
         - Updated PDU, moving client/server decoder into pdu
-    - better broadcast handling
-    - better broadcast handling
+    - better client no_response handling
     - Simplify PDU classes
     - better retry handling (only disconnect when really needed)
 - 3.7.5, bug fix release, hopefully with:

examples/client_custom_msg.py

@@ -26,7 +26,7 @@
 # Since the function code is already registered with the decoder factory,
 # this will be decoded as a read coil response. If you implement a new
 # method that is not currently implemented, you must register the request
-# and response with a ClientDecoder factory.
+# and response with a DecoderResponses factory.
 # --------------------------------------------------------------------------- #
 
 

examples/message_parser.py

@@ -17,7 +17,7 @@
     FramerRTU,
     FramerSocket,
 )
-from pymodbus.pdu import ClientDecoder, ServerDecoder
+from pymodbus.pdu import DecoderRequests, DecoderResponses
 
 
 _logger = logging.getLogger(__file__)
@@ -73,8 +73,8 @@ def decode(self, message):
         print(f"Decoding Message {value}")
         print("=" * 80)
         decoders = [
-            self.framer(ServerDecoder()),
-            self.framer(ClientDecoder()),
+            self.framer(DecoderRequests()),
+            self.framer(DecoderResponses()),
         ]
         for decoder in decoders:
             print(f"{decoder.decoder.__class__.__name__}")

pymodbus/client/base.py

@@ -11,7 +11,7 @@
 from pymodbus.exceptions import ConnectionException, ModbusIOException
 from pymodbus.framer import FRAMER_NAME_TO_CLASS, FramerBase, FramerType
 from pymodbus.logging import Log
-from pymodbus.pdu import ClientDecoder, ModbusPDU
+from pymodbus.pdu import DecoderResponses, ModbusPDU
 from pymodbus.transaction import SyncModbusTransactionManager
 from pymodbus.transport import CommParams
 from pymodbus.utilities import ModbusTransactionState
@@ -182,7 +182,7 @@ def __init__(
         self.slaves: list[int] = []
 
         # Common variables.
-        self.framer: FramerBase = (FRAMER_NAME_TO_CLASS[framer])(ClientDecoder())
+        self.framer: FramerBase = (FRAMER_NAME_TO_CLASS[framer])(DecoderResponses())
         self.transaction = SyncModbusTransactionManager(
             self,
             self.retries,

pymodbus/client/modbusclientprotocol.py

@@ -9,7 +9,7 @@
     FramerType,
 )
 from pymodbus.logging import Log
-from pymodbus.pdu import ClientDecoder
+from pymodbus.pdu import DecoderResponses
 from pymodbus.transaction import ModbusTransactionManager
 from pymodbus.transport import CommParams, ModbusProtocol
 
@@ -35,7 +35,7 @@ def __init__(
         self.on_connect_callback = on_connect_callback
 
         # Common variables.
-        self.framer: FramerBase = (FRAMER_NAME_TO_CLASS[framer])(ClientDecoder())
+        self.framer: FramerBase = (FRAMER_NAME_TO_CLASS[framer])(DecoderResponses())
         self.transaction = ModbusTransactionManager()
 
     def _handle_response(self, reply):

pymodbus/framer/base.py

@@ -10,7 +10,7 @@
 
 from pymodbus.exceptions import ModbusIOException
 from pymodbus.logging import Log
-from pymodbus.pdu import ClientDecoder, ModbusPDU, ServerDecoder
+from pymodbus.pdu import DecoderRequests, DecoderResponses, ModbusPDU
 
 
 class FramerType(str, Enum):
@@ -30,7 +30,7 @@ class FramerBase:
 
     def __init__(
         self,
-        decoder: ClientDecoder | ServerDecoder,
+        decoder: DecoderResponses | DecoderRequests,
     ) -> None:
         """Initialize a ADU (framer) instance."""
         self.decoder = decoder

pymodbus/pdu/__init__.py

@@ -1,13 +1,13 @@
 """Framer."""
 __all__ = [
-    "ClientDecoder",
+    "DecoderRequests",
+    "DecoderResponses",
     "ExceptionResponse",
     "ModbusExceptions",
     "ModbusPDU",
-    "ServerDecoder"
 ]
 
-from pymodbus.pdu.decoders import ClientDecoder, ServerDecoder
+from pymodbus.pdu.decoders import DecoderRequests, DecoderResponses
 from pymodbus.pdu.pdu import (
     ExceptionResponse,
     ModbusExceptions,

pymodbus/pdu/decoders.py

@@ -1,15 +1,4 @@
-"""Modbus Request/Response Decoder Factories.
-
-The following factories make it easy to decode request/response messages.
-To add a new request/response pair to be decodeable by the library, simply
-add them to the respective function lookup table (order doesn't matter, but
-it does help keep things organized).
-
-Regardless of how many functions are added to the lookup, O(1) behavior is
-kept as a result of a pre-computed lookup dictionary.
-"""
-
-# pylint: disable=missing-type-doc
+"""Modbus Request/Response Decoders."""
 from collections.abc import Callable
 
 import pymodbus.pdu.bit_read_message as bit_r_msg
@@ -28,11 +17,8 @@
 # --------------------------------------------------------------------------- #
 # Server Decoder
 # --------------------------------------------------------------------------- #
-class ServerDecoder:
-    """Request Message Factory (Server).
-
-    To add more implemented functions, simply add them to the list
-    """
+class DecoderRequests:
+    """Decode request Message (Server)."""
 
     __function_table = [
         reg_r_msg.ReadHoldingRegistersRequest,
@@ -90,33 +76,19 @@ def __init__(self) -> None:
             self.__sub_lookup[f.function_code][f.sub_function_code] = f  # type: ignore[attr-defined]
 
     def decode(self, message):
-        """Decode a request packet.
-
-        :param message: The raw modbus request packet
-        :return: The decoded modbus message or None if error
-        """
+        """Decode a request packet."""
         try:
             return self._helper(message)
         except ModbusException as exc:
             Log.warning("Unable to decode request {}", exc)
         return None
 
     def lookupPduClass(self, function_code):
-        """Use `function_code` to determine the class of the PDU.
-
-        :param function_code: The function code specified in a frame.
-        :returns: The class of the PDU that has a matching `function_code`.
-        """
+        """Use `function_code` to determine the class of the PDU."""
         return self.lookup.get(function_code, base.ExceptionResponse)
 
     def _helper(self, data: str):
-        """Generate the correct request object from a valid request packet.
-
-        This decodes from a list of the currently implemented request types.
-
-        :param data: The request packet to decode
-        :returns: The decoded request or illegal function request object
-        """
+        """Generate the correct request object from a valid request packet."""
         function_code = int(data[0])
         if not (request := self.lookup.get(function_code, lambda: None)()):
             Log.debug("Factory Request[{}]", function_code)
@@ -144,11 +116,7 @@ def _helper(self, data: str):
         return request
 
     def register(self, function):
-        """Register a function and sub function class with the decoder.
-
-        :param function: Custom function class to register
-        :raises MessageRegisterException:
-        """
+        """Register a function and sub function class with the decoder."""
         if not issubclass(function, base.ModbusPDU):
             raise MessageRegisterException(
                 f'"{function.__class__.__name__}" is Not a valid Modbus Message'
@@ -167,7 +135,7 @@ def register(self, function):
 # --------------------------------------------------------------------------- #
 # Client Decoder
 # --------------------------------------------------------------------------- #
-class ClientDecoder:
+class DecoderResponses:
     """Response Message Factory (Client).
 
     To add more implemented functions, simply add them to the list
@@ -224,19 +192,11 @@ def __init__(self) -> None:
             self.__sub_lookup[f.function_code][f.sub_function_code] = f  # type: ignore[attr-defined]
 
     def lookupPduClass(self, function_code):
-        """Use `function_code` to determine the class of the PDU.
-
-        :param function_code: The function code specified in a frame.
-        :returns: The class of the PDU that has a matching `function_code`.
-        """
+        """Use `function_code` to determine the class of the PDU."""
         return self.lookup.get(function_code, base.ExceptionResponse)
 
     def decode(self, message):
-        """Decode a response packet.
-
-        :param message: The raw packet to decode
-        :return: The decoded modbus message or None if error
-        """
+        """Decode a response packet."""
         try:
             return self._helper(message)
         except ModbusException as exc:

pymodbus/server/async_io.py

@@ -12,8 +12,8 @@
 from pymodbus.exceptions import NoSuchSlaveException
 from pymodbus.framer import FRAMER_NAME_TO_CLASS, FramerBase, FramerType
 from pymodbus.logging import Log
+from pymodbus.pdu import DecoderRequests
 from pymodbus.pdu import ModbusExceptions as merror
-from pymodbus.pdu import ServerDecoder
 from pymodbus.transport import CommParams, CommType, ModbusProtocol
 
 
@@ -257,7 +257,7 @@ def __init__(
             True,
         )
         self.loop = asyncio.get_running_loop()
-        self.decoder = ServerDecoder()
+        self.decoder = DecoderRequests()
         self.context = context or ModbusServerContext()
         self.control = ModbusControlBlock()
         self.ignore_missing_slaves = ignore_missing_slaves

pymodbus/server/simulator/http_server.py

@@ -25,7 +25,7 @@
 from pymodbus.datastore.simulator import Label
 from pymodbus.device import ModbusDeviceIdentification
 from pymodbus.logging import Log
-from pymodbus.pdu import ExceptionResponse, ServerDecoder
+from pymodbus.pdu import DecoderRequests, ExceptionResponse
 from pymodbus.server.async_io import (
     ModbusSerialServer,
     ModbusTcpServer,
@@ -214,7 +214,7 @@ def __init__(
         self.refresh_rate = 0
         self.register_filter: list[int] = []
         self.call_list: list[CallTracer] = []
-        self.request_lookup = ServerDecoder.getFCdict()
+        self.request_lookup = DecoderRequests.getFCdict()
         self.call_monitor = CallTypeMonitor()
         self.call_response = CallTypeResponse()
         app_key = getattr(web, 'AppKey', str)  # fall back to str for aiohttp < 3.9.0

test/framer/conftest.py

@@ -4,7 +4,7 @@
 import pytest
 
 from pymodbus.framer import FRAMER_NAME_TO_CLASS, FramerType
-from pymodbus.pdu import ClientDecoder, ServerDecoder
+from pymodbus.pdu import DecoderRequests, DecoderResponses
 
 
 @pytest.fixture(name="entry")
@@ -21,5 +21,5 @@ def prepare_is_server():
 async def prepare_test_framer(entry, is_server):
     """Return framer object."""
     return FRAMER_NAME_TO_CLASS[entry](
-        (ServerDecoder if is_server else ClientDecoder)(),
+        (DecoderRequests if is_server else DecoderResponses)(),
     )

test/framer/generator.py

@@ -7,7 +7,7 @@
     FramerSocket,
     FramerTLS,
 )
-from pymodbus.pdu import ClientDecoder, ServerDecoder
+from pymodbus.pdu import DecoderRequests, DecoderResponses
 from pymodbus.pdu import ModbusExceptions as merror
 from pymodbus.pdu.register_read_message import (
     ReadHoldingRegistersRequest,
@@ -23,13 +23,13 @@ def set_calls():
             print(f"  dev_id --> {dev_id}")
             for tid in (0, 3077):
                 print(f"    tid --> {tid}")
-                client = framer(ClientDecoder())
+                client = framer(DecoderResponses())
                 request = ReadHoldingRegistersRequest(124, 2, dev_id)
                 request.transaction_id = tid
                 result = client.buildFrame(request)
                 print(f"      request --> {result}")
                 print(f"      request --> {result.hex()}")
-                server = framer(ServerDecoder())
+                server = framer(DecoderRequests())
                 response = ReadHoldingRegistersResponse([141,142])
                 response.slave_id = dev_id
                 response.transaction_id = tid

test/framer/test_extras.py

@@ -6,7 +6,7 @@
     FramerSocket,
     FramerTLS,
 )
-from pymodbus.pdu import ServerDecoder
+from pymodbus.pdu import DecoderRequests
 
 
 TEST_MESSAGE = b"\x7b\x01\x03\x00\x00\x00\x05\x85\xC9\x7d"
@@ -30,7 +30,7 @@ class TestExtas:
     def setup_method(self):
         """Set up the test environment."""
         self.client = None
-        self.decoder = ServerDecoder()
+        self.decoder = DecoderRequests()
         self._tcp = FramerSocket(self.decoder)
         self._tls = FramerTLS(self.decoder)
         self._rtu = FramerRTU(self.decoder)

test/framer/test_framer.py

@@ -11,7 +11,7 @@
     FramerTLS,
     FramerType,
 )
-from pymodbus.pdu import ClientDecoder, ModbusPDU
+from pymodbus.pdu import DecoderResponses, ModbusPDU
 
 from .generator import set_calls
 
@@ -27,7 +27,7 @@ def test_setup(self, entry, is_server):
 
     def test_base(self):
         """Test FramerBase."""
-        framer = FramerBase(ClientDecoder())
+        framer = FramerBase(DecoderResponses())
         framer.decode(b'')
         framer.encode(b'', 0, 0)
         framer.encode(b'', 2, 0)
@@ -189,7 +189,7 @@ def test_encode_type(self, frame, frame_expected, data, dev_id, tr_id, inx1, inx
         """Test encode method."""
         if frame == FramerTLS and dev_id + tr_id:
             return
-        frame_obj = frame(ClientDecoder())
+        frame_obj = frame(DecoderResponses())
         expected = frame_expected[inx1 + inx2 + inx3]
         encoded_data = frame_obj.encode(data, dev_id, tr_id)
         assert encoded_data == expected

test/framer/test_multidrop.py

@@ -5,7 +5,7 @@
 
 from pymodbus.exceptions import ModbusIOException
 from pymodbus.framer import FramerAscii, FramerRTU
-from pymodbus.pdu import ClientDecoder, ServerDecoder
+from pymodbus.pdu import DecoderRequests, DecoderResponses
 
 
 class TestMultidrop:
@@ -16,7 +16,7 @@ class TestMultidrop:
     @pytest.fixture(name="framer")
     def fixture_framer(self):
         """Prepare framer."""
-        return FramerRTU(ServerDecoder())
+        return FramerRTU(DecoderRequests())
 
     @pytest.fixture(name="callback")
     def fixture_callback(self):
@@ -50,7 +50,7 @@ def test_big_split_response_frame_from_other_id(self, framer):
         """Test split response."""
         # This is a single *response* from device id 1 after being queried for 125 holding register values
         # Because the response is so long it spans several serial events
-        framer = FramerRTU(ClientDecoder())
+        framer = FramerRTU(DecoderResponses())
         serial_events = [
             b'\x01\x03\xfa\x00\x11\x00\x11\x00\x11\x00\x11\x00\x11\x00\x11\x00\x11\x00\x11\x00\x11\x00',
             b'\x11\x00\x11\x00\x11\x00\x11\x00\x11\x00\x11\x00\x11\x00\x11\x00\x11\x00\x11\x00\x11\x00',
@@ -153,7 +153,7 @@ def return_none(_data):
             """Return none."""
             return None
 
-        framer = FramerAscii(ServerDecoder())
+        framer = FramerAscii(DecoderRequests())
         framer.decoder.decode = return_none
         with pytest.raises(ModbusIOException):
             framer.processIncomingFrame(b':1103007C00026E\r\n')