fix MRO for async classes

Author: GimmickNG

umodbus/asynchronous/common.py

@@ -31,7 +31,7 @@ async def send_response(self,
         :type       signed:  bool
         """
 
-        print("sending async response...")
+        #print("sending async response...")
         await self._itf.send_response(slave_addr=self.unit_addr,
                                       function_code=self.function,
                                       request_register_addr=self.register_addr,

umodbus/asynchronous/modbus.py

@@ -59,7 +59,7 @@ async def _process_read_access(self,
         """@see Modbus._process_read_access"""
 
         task = super()._process_read_access(request, reg_type)
-        print("async process_read_access task = ", task)
+        #print("async process_read_access task = ", task)
         if task is not None:
             await task
 
@@ -69,6 +69,6 @@ async def _process_write_access(self,
         """@see Modbus._process_write_access"""
 
         task = super()._process_write_access(request, reg_type)
-        print("async process_write_access task = ", task)
+        #print("async process_write_access task = ", task)
         if task is not None:
             await task

umodbus/asynchronous/serial.py

@@ -144,11 +144,8 @@ async def _send(self,
                     slave_addr: int) -> None:
         """@see CommonRTUFunctions._send"""
 
-        print("async RTU: _send() called")
-        post_send_actions = super()._send(device=self,
-                                          modbus_pdu=modbus_pdu,
-                                          slave_addr=slave_addr)
-        await post_send_actions
+        await super()._send(modbus_pdu=modbus_pdu,
+                            slave_addr=slave_addr)
 
     async def _post_send(self, sleep_time_us: float) -> None:
         """
@@ -159,7 +156,6 @@ async def _post_send(self, sleep_time_us: float) -> None:
         @see CommonRTUFunctions._post_send
         """
 
-        print("async RTU: _post_send() called")
         await hybrid_sleep(sleep_time_us)
         if self._ctrlPin:
             self._ctrlPin.off()
@@ -244,15 +240,15 @@ async def send_response(self,
         :type       request:     AsyncRequest, optional
         """
 
-        print("async RTU: calling send_response()")
+        #print("async RTU: calling send_response()")
         task = super().send_response(slave_addr=slave_addr,
                                      function_code=function_code,
                                      request_register_addr=request_register_addr,  # noqa: E501
                                      request_register_qty=request_register_qty,
                                      request_data=request_data,
                                      values=values,
                                      signed=signed)
-        print("async RTU: send_response() called, task is:", task)
+        #print("async RTU: send_response() called, task is:", task)
         if task is not None:
             await task
 
@@ -271,11 +267,11 @@ async def send_exception_response(self,
         :type       request:     AsyncRequest, optional
         """
 
-        print("async RTU: calling send_exception_response()")
+        #print("async RTU: calling send_exception_response()")
         task = super().send_exception_response(slave_addr=slave_addr,
                                                function_code=function_code,
                                                exception_code=exception_code)
-        print("async RTU: called send_exception_response(), task is:", task)
+        #print("async RTU: called send_exception_response(), task is:", task)
         if task is not None:
             await task
 
@@ -298,7 +294,7 @@ def set_params(self,
         self.req_handler = req_handler
 
 
-class AsyncSerial(CommonRTUFunctions, CommonAsyncRTUFunctions, CommonAsyncModbusFunctions):
+class AsyncSerial(CommonAsyncRTUFunctions, CommonAsyncModbusFunctions, CommonRTUFunctions):
     """Asynchronous Modbus Serial client"""
 
     def __init__(self,

umodbus/modbus.py

@@ -204,7 +204,7 @@ def _process_read_access(self, request: Request, reg_type: str) \
                 _cb = self._register_dict[reg_type][address]['on_get_cb']
                 _cb(reg_type=reg_type, address=address, val=vals)
 
-            print("creating response...", type(self).__name__, "->", type(request).__name__)
+            #print("creating response...", type(self).__name__, "->", type(request).__name__)
             vals = self._create_response(request=request, reg_type=reg_type)
             return request.send_response(vals)
         else:

umodbus/serial.py

@@ -103,6 +103,8 @@ def __init__(self,
         :param      read_timeout:   The read timeout in ms.
         :type       read_timeout:   int
         """
+
+        super().__init__()
         # UART flush function is introduced in Micropython v1.20.0
         self._has_uart_flush = callable(getattr(UART, "flush", None))
         self._uart = UART(uart_id,