Activate pylint enable=all, to give max. control. (#872)

janiversen · web-flow · commit b14f325bfc18 · 2022-05-03T17:38:05.000+02:00
diff --git a/.pylintrc b/.pylintrc
@@ -78,21 +78,14 @@ fail-on=
 # confidence=
 
 # Enable/Disable the message/report/category/checker with the given id(s).
-enable=
-    attribute-defined-outside-init,
-    fixme,
-    invalid-name,
-    missing-docstring,
-    no-self-use,
-    protected-access,
-    too-few-public-methods,
+enable=all
 
 disable= 
-    duplicate-code,
-    logging-too-many-args,
-    use-symbolic-message-instead,
-    useless-suppression,
-    format # handled by black
+    duplicate-code,                # TBD
+    file-ignored,                  # ONLY to be used with extreme care.
+    format,                        # NOT wanted, handled by black
+    locally-disabled,              # NOT wanted
+    suppressed-message,            # NOT wanted
 
 
 [REPORTS]
diff --git a/doc/api/pydoc/build.py b/doc/api/pydoc/build.py
@@ -1,4 +1,5 @@
-#!/usr/bin/env python3 # pylint: disable-all
+#!/usr/bin/env python3
+# pylint: skip-file
 """Pydoc sub-class for generating documentation for entire packages.
 
 Taken from: http://pyopengl.sourceforge.net/pydoc/OpenGLContext.pydoc.pydoc2.html
diff --git a/examples/common/async_asyncio_client.py b/examples/common/async_asyncio_client.py
@@ -131,8 +131,9 @@ def run_with_not_running_loop():
     loop = asyncio.new_event_loop()
     assert not loop.is_running()  # nosec
     asyncio.set_event_loop(loop)
-    new_loop, client = ModbusClient(schedulers.ASYNC_IO,  # NOSONAR pylint: disable=unpacking-non-sequence
-                                    port=5020, loop=loop)
+    new_loop, client = ModbusClient(  # NOSONAR pylint: disable=unpacking-non-sequence
+        schedulers.ASYNC_IO,
+        port=5020, loop=loop)
     loop.run_until_complete(start_async_test(client.protocol))
     loop.close()
     _logger.debug("--------------RUN_WITH_NOT_RUNNING_LOOP---------------")
diff --git a/examples/contrib/concurrent_client.py b/examples/contrib/concurrent_client.py
@@ -87,16 +87,19 @@ def _client_worker_process(factory, input_queue, output_queue, is_shutdown):
     :param output_queue: The queue to place client responses
     :param is_shutdown: Condition variable marking process shutdown
     """
-    log.info("starting up worker : %s", threading.current_thread())
+    txt = f"starting up worker : {threading.current_thread()}"
+    log.info(txt)
     my_client = factory()
     while not is_shutdown.is_set():
         try:
             workitem = input_queue.get(timeout=1)
-            log.debug("dequeue worker request: %s", workitem)
+            txt = f"dequeue worker request: {workitem}"
+            log.debug(txt)
             if not workitem:
                 continue
             try:
-                log.debug("executing request on thread: %s", workitem)
+                txt = f"executing request on thread: {workitem}"
+                log.debug(txt)
                 result = my_client.execute(workitem.request)
                 output_queue.put(WorkResponse(False, workitem.work_id, result))
             except Exception as exc:  # pylint: disable=broad-except
@@ -106,7 +109,8 @@ def _client_worker_process(factory, input_queue, output_queue, is_shutdown):
                                               workitem.work_id, exc))
         except Exception:  # nosec pylint: disable=broad-except
             pass
-    log.info("request worker shutting down: %s", threading.current_thread())
+    txt = f"request worker shutting down: {threading.current_thread()}"
+    log.info(txt)
 
 
 def _manager_worker_process(output_queue, my_futures, is_shutdown):
@@ -124,12 +128,14 @@ def _manager_worker_process(output_queue, my_futures, is_shutdown):
     :param futures: The mapping of tid -> future
     :param is_shutdown: Condition variable marking process shutdown
     """
-    log.info("starting up manager worker: %s", threading.current_thread())
+    txt = f"starting up manager worker: {threading.current_thread()}"
+    log.info(txt)
     while not is_shutdown.is_set():
         try:
             workitem = output_queue.get()
             my_future = my_futures.get(workitem.work_id, None)
-            log.debug("dequeue manager response: %s", workitem)
+            txt = f"dequeue manager response: {workitem}"
+            log.debug(txt)
             if not my_future:
                 continue
             if workitem.is_exception:
@@ -227,7 +233,8 @@ def execute_silently(self, request):
 
     def client_factory():
         """Client factory."""
-        log.debug("creating client for: %s", threading.current_thread())
+        txt = f"creating client for: {threading.current_thread()}"
+        log.debug(txt)
         my_client = ModbusTcpClient('127.0.0.1', port=5020)
         my_client.connect()
         return client
@@ -238,6 +245,7 @@ def client_factory():
         futures = [client.read_coils(i * 8, 8) for i in range(10)]
         log.info("waiting on futures to complete")
         for future in futures:
-            log.info("future result: %s", future.result(timeout=1))
+            txt = f"future result: {future.result(timeout=1)}"
+            log.info(txt)
     finally:
         client.shutdown()
diff --git a/pymodbus/client/asynchronous/factory/serial.py b/pymodbus/client/asynchronous/factory/serial.py
@@ -70,7 +70,7 @@ def io_loop_factory(port=None, framer=None, **kwargs):
     """
     from tornado.ioloop import IOLoop  # pylint: disable=import-outside-toplevel
     from pymodbus.client.asynchronous.tornado import (  # pylint: disable=import-outside-toplevel
-        AsyncModbusSerialClient as Client)  # pylint: disable=import-outside-toplevel
+        AsyncModbusSerialClient as Client)
 
     ioloop = IOLoop()
     protocol = EventLoopThread("ioloop", ioloop.start, ioloop.stop)
diff --git a/pymodbus/client/asynchronous/tornado/__init__.py b/pymodbus/client/asynchronous/tornado/__init__.py
@@ -416,8 +416,7 @@ def _on_receive(fd, events):
 
         if self.timeout:
             self.timeout_handle = self.io_loop.add_timeout(  # pylint: disable=attribute-defined-outside-init
-                time.time() + self.timeout,
-                _on_timeout)  # pylint: disable=attribute-defined-outside-init
+                time.time() + self.timeout, _on_timeout)
         self._send_packet(packet, callback=_on_write_done)
 
         return response
diff --git a/pymodbus/device.py b/pymodbus/device.py
@@ -275,13 +275,13 @@ def __str__(self):
     # -------------------------------------------------------------------------#
     #  Properties
     # -------------------------------------------------------------------------#
-    VendorName = dict_property(lambda s: s.__data, 0)  # NOSONAR pylint: disable=protected-access,invalid-name
-    ProductCode = dict_property(lambda s: s.__data, 1)  # NOSONAR pylint: disable=protected-access,invalid-name
-    MajorMinorRevision = dict_property(lambda s: s.__data, 2)  # NOSONAR pylint: disable=protected-access,invalid-name
-    VendorUrl = dict_property(lambda s: s.__data, 3)  # NOSONAR pylint: disable=protected-access,invalid-name
-    ProductName = dict_property(lambda s: s.__data, 4)  # NOSONAR pylint: disable=protected-access,invalid-name
-    ModelName = dict_property(lambda s: s.__data, 5)  # NOSONAR pylint: disable=protected-access,invalid-name
-    UserApplicationName = dict_property(lambda s: s.__data, 6)  # NOSONAR pylint: disable=protected-access,invalid-name
+    VendorName = dict_property(lambda s: s.__data, 0)  # NOSONAR pylint: disable=protected-access
+    ProductCode = dict_property(lambda s: s.__data, 1)  # NOSONAR pylint: disable=protected-access
+    MajorMinorRevision = dict_property(lambda s: s.__data, 2)  # NOSONAR pylint: disable=protected-access
+    VendorUrl = dict_property(lambda s: s.__data, 3)  # NOSONAR pylint: disable=protected-access
+    ProductName = dict_property(lambda s: s.__data, 4)  # NOSONAR pylint: disable=protected-access
+    ModelName = dict_property(lambda s: s.__data, 5)  # NOSONAR pylint: disable=protected-access
+    UserApplicationName = dict_property(lambda s: s.__data, 6)  # NOSONAR pylint: disable=protected-access
 
 
 class DeviceInformationFactory(Singleton):  # pylint: disable=too-few-public-methods
diff --git a/pymodbus/diag_message.py b/pymodbus/diag_message.py
@@ -57,7 +57,7 @@ def decode(self, data):
 
         :param data: The data to decode into the function code
         """
-        self.sub_function_code, self.message = struct.unpack('>HH', data)  # pylint: disable=W0201
+        self.sub_function_code, self.message = struct.unpack('>HH', data)  # noqa E501 pylint: disable=attribute-defined-outside-init
 
     def get_response_pdu_size(self):
         """Get response pdu size.
diff --git a/pymodbus/factory.py b/pymodbus/factory.py
@@ -166,7 +166,8 @@ class ServerDecoder(IModbusDecoder):
     def __init__(self):
         """Initialize the client lookup tables."""
         functions = set(f.function_code for f in self.__function_table)
-        self.__lookup = dict([(f.function_code, f) for f in self.__function_table])  # pylint: disable=R1717
+        self.__lookup = dict(  # pylint: disable=consider-using-dict-comprehension
+            [(f.function_code, f) for f in self.__function_table])
         self.__sub_lookup = dict((f, {}) for f in functions)
         for f in self.__sub_function_table:
             self.__sub_lookup[f.function_code][f.sub_function_code] = f
diff --git a/pymodbus/payload.py b/pymodbus/payload.py
@@ -311,7 +311,9 @@ def bit_chunks(cls, coils, size=8):
         return chunks
 
     @classmethod
-    def fromCoils(cls, coils, byteorder=Endian.Little, wordorder=Endian.Big):  # NOSONAR pylint: disable=C0103,W0613
+    def fromCoils(cls,  # NOSONAR pylint: disable=invalid-name
+                  coils, byteorder=Endian.Little,
+                  wordorder=Endian.Big):  # NOSONAR pylint: disable=unused-argument
         """Initialize a payload decoder with the result of reading of coils.
 
         The coils are treated as a list of bit(boolean) values.
diff --git a/pymodbus/repl/client/main.py b/pymodbus/repl/client/main.py
@@ -42,11 +42,11 @@
 TITLE = (
     r'----------------------------------------------------------------------------'
     r'__________          _____             .___  __________              .__   '
-    r'\______   \___.__. /     \   ____   __| _/  \______   \ ____ ______ |  |  '  # pylint: disable=C0209
-    r' |     ___<   |  |/  \ /  \ /  _ \ / __ |    |       _// __ \\\____ \|  |  '  # pylint: disable=C0209
-    r' |    |    \___  /    Y    (  <_> ) /_/ |    |    |   \  ___/|  |_> >  |__'  # pylint: disable=C0209
-    r' |____|    / ____\____|__  /\____/\____ | /\ |____|_  /\___  >   __/|____/'  # pylint: disable=C0209
-    r'           \/            \/            \/ \/        \/     \/|__|'  # pylint: disable=C0209
+    r'\______   \___.__. /     \   ____   __| _/  \______   \ ____ ______ |  |  '
+    r' |     ___<   |  |/  \ /  \ /  _ \ / __ |    |       _// __ \\\____ \|  |  '
+    r' |    |    \___  /    Y    (  <_> ) /_/ |    |    |   \  ___/|  |_> >  |__'
+    r' |____|    / ____\____|__  /\____/\____ | /\ |____|_  /\___  >   __/|____/'
+    r'           \/            \/            \/ \/        \/     \/|__|'
     f'                                        v1.3.0 - {version}'
     r'----------------------------------------------------------------------------'
 )
diff --git a/pymodbus/repl/server/cli.py b/pymodbus/repl/server/cli.py
@@ -107,7 +107,7 @@ def print_help():
     print_formatted_text(HTML("<u>Available commands:</u>"))
     for cmd, hlp in sorted(COMMAND_HELPS.items()):
         print_formatted_text(
-            HTML("<skyblue>{:45s}</skyblue><seagreen>{:100s}</seagreen>".format(cmd, hlp)  # pylint: disable=C0209
+            HTML("<skyblue>{cmd:45s}</skyblue><seagreen>{hlp:100s}</seagreen>"
                  )
         )
 
diff --git a/pymodbus/server/asynchronous.py b/pymodbus/server/asynchronous.py
@@ -233,7 +233,8 @@ def _is_main_thread():
 
 def StartTcpServer(context,  # NOSONAR pylint: disable=dangerous-default-value,invalid-name
                    identity=None, address=None,
-                   console=False, defer_reactor_run=False,  # NOSONAR pylint: disable=W0613,
+                   console=False,  # NOSONAR pylint: disable=unused-argument,
+                   defer_reactor_run=False,
                    custom_functions=[],
                    **kwargs):
     """Start the Modbus Async TCP server.
diff --git a/pymodbus/server/reactive/main.py b/pymodbus/server/reactive/main.py
@@ -221,7 +221,7 @@ def manipulate_response(self, response):
             delay_by = self._manipulator_config.get("delay_by")
             txt = f"Delaying response by {delay_by}s for all incoming requests"
             logger.warning(txt)
-            time.sleep(delay_by)  # change to async TODO pylint: disable:fixme
+            time.sleep(delay_by)  # change to async
             self._counter += 1
         elif response_type == "empty":
             logger.warning("Sending empty response")
diff --git a/pymodbus/server/sync.py b/pymodbus/server/sync.py
@@ -73,8 +73,8 @@ def execute(self, request):
                 return  # the client will simply timeout waiting for a response
             response = request.doException(merror.GatewayNoResponse)
         except Exception as exc:  # pylint: disable=broad-except
-            _logger.debug("Datastore unable to fulfill request: "
-                          "%s; %s", exc, traceback.format_exc())
+            txt = f"Datastore unable to fulfill request: {exc} {traceback.format_exc()}"
+            _logger.debug(txt)
             response = request.doException(merror.SlaveFailure)
         # no response when broadcasting
         if not broadcast:
@@ -203,7 +203,8 @@ def handle(self):  # pylint: disable=too-complex
                                                   single=single)
             except socket.timeout as msg:
                 if _logger.isEnabledFor(logging.DEBUG):
-                    _logger.debug("Socket timeout occurred %s", msg)
+                    txt = f"Socket timeout occurred {msg}"
+                    _logger.debug(txt)
                 reset_frame = True
             except socket.error as msg:
                 txt = f"Socket error occurred {msg}"
@@ -670,7 +671,7 @@ def StartUdpServer(context=None, identity=None, address=None,  # pylint: disable
     server.serve_forever()
 
 
-def StartSerialServer(context=None,  # pylint: disable=invalid-name, dangerous-default-value
+def StartSerialServer(context=None,  # NOSONAR pylint: disable=invalid-name, dangerous-default-value
                       identity=None, custom_functions=[],
                       **kwargs):
     """Start and run a serial modbus server.
diff --git a/test/test_client_async_tornado.py b/test/test_client_async_tornado.py
@@ -263,9 +263,8 @@ def test_serial_client_handle_response(self, mock_serial,  # pylint: disable=unu
     @patch("pymodbus.client.asynchronous.tornado.Serial")
     def test_serial_client_build_response(self,
                                           mock_serial,  # pylint: disable=unused-argument
-                                          mock_seriostream,  # pylint: disable=unused-argument
-                                          mock_ioloop):  # pylint: disable=unused-argument
-        """Test the tornado serial client client builds responses"""
+                                          mock_seriostream, mock_ioloop):  # pylint: disable=unused-argument
+        """Test the tornado serial client client builds responses."""
         client = AsyncModbusSerialClient(ioloop=schedulers.IO_LOOP,
                                          framer=ModbusRtuFramer(
                                              ClientDecoder()),
diff --git a/test/test_client_sync.py b/test/test_client_sync.py
@@ -95,8 +95,7 @@ def test_base_modbus_client(self):
         self.assertRaises(NotImplementedException, lambda: client.recv(None))
         self.assertRaises(NotImplementedException, lambda: client.__enter__())  # pylint: disable=unnecessary-lambda
         self.assertRaises(NotImplementedException, lambda: client.execute())  # pylint: disable=unnecessary-lambda
-        self.assertRaises(NotImplementedException, lambda: client.is_socket_open()  # pylint: disable=unnecessary-lambda
-                          )  # pylint: disable=unnecessary-lambda
+        self.assertRaises(NotImplementedException, lambda: client.is_socket_open())  # noqa E501 pylint: disable=unnecessary-lambda
         self.assertEqual("Null Transport", str(client))
         client.close()
         client.__exit__(0, 0, 0)
diff --git a/test/test_transaction.py b/test/test_transaction.py
@@ -155,7 +155,7 @@ def test_execute(self, mock_time):
         # retry on invalid response
         trans.retry_on_invalid = True
         trans._recv = MagicMock(side_effect=iter(  # pylint: disable=protected-access
-            [b'', b'abcdef', b'deadbe', b'123456']))  # pylint: disable=protected-access
+            [b'', b'abcdef', b'deadbe', b'123456']))
         # tm._transact.side_effect = [(b'', None), (b'abcdef', None)]
         response = trans.execute(request)
         self.assertIsInstance(response, ModbusIOException)
