Fix Flake8 issue

hmaerki · Jan 19, 2024 · 6b61e8f · 6b61e8f
1 parent 0951f54
commit 6b61e8f
Show file tree

Hide file tree

Showing 5 changed files with 10 additions and 10 deletions.
diff --git a/umodbus/asynchronous/common.py b/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,

diff --git a/umodbus/asynchronous/modbus.py b/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
diff --git a/umodbus/asynchronous/serial.py b/umodbus/asynchronous/serial.py
@@ -234,15 +234,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
 
@@ -261,11 +261,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
 

diff --git a/umodbus/modbus.py b/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:

diff --git a/umodbus/serial.py b/umodbus/serial.py
@@ -230,14 +230,14 @@ def _send(self, modbus_pdu: bytes, slave_addr: int) -> Optional[Awaitable]:
                 100     # only required at baudrates above 57600, but hey 100us
             )
 
-        #print("serial::_send -> _post_send()")
+        # print("serial::_send -> _post_send()")
         return self._post_send(sleep_time_us)
 
     def _post_send(self, sleep_time_us: float) -> None:
         """
         Sleeps after sending a request, along with other post-send actions.
         """
-        #print("serial::post_send")
+        # print("serial::post_send")
         time.sleep_us(sleep_time_us)
         if self._ctrlPin:
             self._ctrlPin.off()