Add flake8-comprehensions. (#892)

janiversen · web-flow · commit d03749a2d944 · 2022-05-18T09:59:35.000+02:00
diff --git a/TODO_add_checks b/TODO_add_checks
@@ -3,9 +3,7 @@
 2) new checks
 - flake8 addons:
     pycodestyle
-    pyflakes
     pydocstyle
-    flake8-comprehensions
 
 - prettier
 - mypy
diff --git a/examples/contrib/remote_server_context.py b/examples/contrib/remote_server_context.py
@@ -118,9 +118,9 @@ def __extract_result(self, f_code, result):  # pylint: disable=no-self-use
         :param result: The resulting data
         """
         if not result.isError():
-            if f_code in set(['d', 'c']):
+            if f_code in {'d', 'c'}:
                 return result.bits
-            if f_code in set(['h', 'i']):
+            if f_code in {'h', 'i'}:
                 return result.registers
             return None
         return result
diff --git a/pymodbus/datastore/remote.py b/pymodbus/datastore/remote.py
@@ -104,9 +104,9 @@ def __extract_result(self, fc_as_hex, result):  # pylint: disable=no-self-use
         TODO make this consistent (values?)
         """
         if not result.isError():
-            if fc_as_hex in set(['d', 'c']):
+            if fc_as_hex in {'d', 'c'}:
                 return result.bits
-            if fc_as_hex in set(['h', 'i']):
+            if fc_as_hex in {'h', 'i'}:
                 return result.registers
         else:
             return result
diff --git a/pymodbus/datastore/store.py b/pymodbus/datastore/store.py
@@ -293,7 +293,7 @@ def setValues(self, address, values, use_as_default=False):
         :param use_as_default: Use the values as default
         """
         if isinstance(values, dict):
-            new_offsets = list(set(list(values.keys())) - set(list(self.values.keys())))
+            new_offsets = list(set(list(values.keys())) - set(list(self.values.keys())))  # noqa: C414
             if new_offsets and not self.mutable:
                 raise ParameterException(f"Offsets {new_offsets} not in range")
             self._process_values(values)
diff --git a/pymodbus/device.py b/pymodbus/device.py
@@ -333,7 +333,7 @@ def __gets(cls, identity, object_ids):  # NOSONAR pylint: disable=unused-private
         :param object_ids: The specific object ids to read
         :returns: The requested data (id, length, value)
         """
-        return dict((oid, identity[oid]) for oid in object_ids if identity[oid])
+        return {oid: identity[oid] for oid in object_ids if identity[oid]}
 
 
 # ---------------------------------------------------------------------------#
@@ -408,7 +408,7 @@ class ModbusCountersHandler:
     .. note:: I threw the event counter in here for convenience
     """
 
-    __data = dict([(i, 0x0000) for i in range(9)])  # pylint: disable=consider-using-dict-comprehension
+    __data = {i: 0x0000 for i in range(9)}  # pylint: disable=consider-using-dict-comprehension
     __names = [
         'BusMessage',
         'BusCommunicationError',
@@ -441,7 +441,7 @@ def update(self, values):
 
     def reset(self):
         """Clear all of the system counters."""
-        self.__data = dict([(i, 0x0000) for i in range(9)])  # pylint: disable=consider-using-dict-comprehension
+        self.__data = {i: 0x0000 for i in range(9)}  # pylint: disable=consider-using-dict-comprehension
 
     def summary(self):
         """Return a summary of the counters current status.
@@ -564,7 +564,7 @@ def _setMode(self, mode):  # pylint: disable=invalid-name
 
         :param mode: The data transfer method in (RTU, ASCII)
         """
-        if mode in set(['ASCII', 'RTU']):
+        if mode in {'ASCII', 'RTU'}:
             self.__mode = mode  # pylint: disable=unused-private-member
 
     Mode = property(lambda s: s.__mode, _setMode)
diff --git a/pymodbus/factory.py b/pymodbus/factory.py
@@ -165,10 +165,10 @@ 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(  # 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)
+        functions = {f.function_code for f in self.__function_table}
+        self.__lookup = {  # pylint: disable=consider-using-dict-comprehension
+            f.function_code: f for f in self.__function_table}
+        self.__sub_lookup = {f: {} for f in functions}
         for f in self.__sub_function_table:
             self.__sub_lookup[f.function_code][f.sub_function_code] = f
 
@@ -295,10 +295,10 @@ class ClientDecoder(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)  # pylint: disable=consider-using-dict-comprehension
-                              for f in self.__function_table])
-        self.__sub_lookup = dict((f, {}) for f in functions)
+        functions = {f.function_code for f in self.__function_table}
+        self.__lookup = {f.function_code: f  # pylint: disable=consider-using-dict-comprehension
+                         for f in self.__function_table}
+        self.__sub_lookup = {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/framer/ascii_framer.py b/pymodbus/framer/ascii_framer.py
@@ -55,7 +55,7 @@ def decode_data(self, data):  # pylint: disable=no-self-use
         if len(data) > 1:
             uid = int(data[1:3], 16)
             fcode = int(data[3:5], 16)
-            return dict(unit=uid, fcode=fcode)
+            return {'unit': uid, 'fcode': fcode}
         return {}
 
     def checkFrame(self):
diff --git a/pymodbus/framer/binary_framer.py b/pymodbus/framer/binary_framer.py
@@ -63,7 +63,7 @@ def decode_data(self, data):
         if len(data) > self._hsize:
             uid = struct.unpack('>B', data[1:2])[0]
             fcode = struct.unpack('>B', data[2:3])[0]
-            return dict(unit=uid, fcode=fcode)
+            return {'unit': uid, 'fcode': fcode}
         return {}
 
     def checkFrame(self):
diff --git a/pymodbus/framer/rtu_framer.py b/pymodbus/framer/rtu_framer.py
@@ -74,7 +74,7 @@ def decode_data(self, data):
         if len(data) > self._hsize:
             uid = int(data[0])
             fcode = int(data[1])
-            return dict(unit=uid, fcode=fcode)
+            return {'unit': uid, 'fcode': fcode}
         return {}
 
     def checkFrame(self):
diff --git a/pymodbus/framer/socket_framer.py b/pymodbus/framer/socket_framer.py
@@ -124,7 +124,13 @@ def decode_data(self, data):
         if len(data) > self._hsize:
             tid, pid, length, uid, fcode = struct.unpack(SOCKET_FRAME_HEADER,
                                                          data[0:self._hsize + 1])
-            return dict(tid=tid, pid=pid, length=length, unit=uid, fcode=fcode)
+            return {
+                'tid': tid,
+                'pid': pid,
+                'length': length,
+                'unit': uid,
+                'fcode': fcode,
+            }
         return {}
 
     def processIncomingPacket(self, data, callback, unit, **kwargs):  # NOSONAR pylint: disable=arguments-differ
diff --git a/pymodbus/framer/tls_framer.py b/pymodbus/framer/tls_framer.py
@@ -104,7 +104,7 @@ def decode_data(self, data):
         """Decode data."""
         if len(data) > self._hsize:
             (fcode,) = struct.unpack(TLS_FRAME_HEADER, data[0:self._hsize + 1])
-            return dict(fcode=fcode)
+            return {'fcode': fcode}
         return {}
 
     def processIncomingPacket(self, data, callback, unit, **kwargs):  # pylint: disable=arguments-differ
diff --git a/pymodbus/pdu.py b/pymodbus/pdu.py
@@ -153,8 +153,8 @@ def decode(cls, code):
 
         :param code: The code number to translate
         """
-        values = dict((v, k) for k, v in iter(cls.__dict__.items())
-                      if not k.startswith('__') and not callable(v))
+        values = {v: k for k, v in iter(cls.__dict__.items())
+                  if not k.startswith('__') and not callable(v)}
         return values.get(code, None)
 
 
diff --git a/pymodbus/repl/client/main.py b/pymodbus/repl/client/main.py
@@ -275,7 +275,7 @@ def main(ctx, verbose, broadcast_support, retry_on_empty,
 )
 def tcp(ctx, host, port, framer):
     """Define TCP."""
-    kwargs = dict(host=host, port=port)
+    kwargs = {'host': host, 'port': port}
     kwargs.update(**ctx.obj)
     if framer == 'rtu':
         kwargs['framer'] = ModbusRtuFramer
diff --git a/pymodbus/repl/server/cli.py b/pymodbus/repl/server/cli.py
@@ -172,8 +172,11 @@ async def interactive_shell(server):  # NOSONAR
                                 warning(f"Invalid response type request - {value}")
                                 warning(f"Choose from {RESPONSE_TYPES}")
                                 valid = False
-                        elif arg in set(["error_code", "delay_by",  # pylint: disable=confusing-consecutive-elif
-                                         "clear_after", "data_len"]):
+                        elif arg in {  # pylint: disable=confusing-consecutive-elif
+                                "error_code",
+                                "delay_by",
+                                "clear_after",
+                                "data_len"}:
                             try:
                                 value = int(value)
                             except ValueError:
diff --git a/requirements.txt b/requirements.txt
@@ -66,6 +66,7 @@ coverage
 flake8
 flake8-docstrings
 flake8-noqa
+flake8-comprehensions
 isort
 pep8
 pyflakes
diff --git a/test/test_client_async.py b/test/test_client_async.py
@@ -203,7 +203,7 @@ def handle_failure(failure):
                                                 ("ascii", ModbusAsciiFramer)])
     def test_serial_tornado_client(self, method, framer):  # pylint: disable=no-self-use
         """Test the serial tornado client client initialize"""
-        with maybe_manage(sys.platform in set(('darwin', 'win32')), patch.object(Serial, "open")):
+        with maybe_manage(sys.platform in {'darwin', 'win32'}, patch.object(Serial, "open")):
             protocol, future = AsyncModbusSerialClient(  # NOSONAR pylint: disable=unpacking-non-sequence
                 schedulers.IO_LOOP, method=method, port=pytest.SERIAL_PORT)
             client = future.result()
diff --git a/test/test_device.py b/test/test_device.py
@@ -300,7 +300,7 @@ def test_modbus_plus_statistics_helpers(self):
             [0, 0, 0, 0, 0, 0, 0, 0], [0, 0], [0], [0, 0, 0, 0, 0, 0, 0, 0],
             [0, 0, 0, 0, 0, 0, 0, 0], [0], [0], [0, 0], [0], [0], [0], [0], [0, 0],
             [0], [0], [0], [0], [0], [0, 0], [0], [0, 0, 0, 0, 0, 0, 0, 0]]
-        stats_summary = [x for x in statistics.summary()]  # pylint: disable=unnecessary-comprehension
+        stats_summary = [x for x in statistics.summary()]  # noqa: C416 pylint: disable=unnecessary-comprehension
         self.assertEqual(sorted(summary), sorted(stats_summary))
         self.assertEqual(0x00, sum(sum(value[1]) for value in statistics))
 
diff --git a/test/test_pdu.py b/test/test_pdu.py
@@ -53,7 +53,7 @@ def test_request_exception_factory(self):
         """Test all error methods"""
         request = ModbusRequest()
         request.function_code = 1
-        errors = dict((ModbusExceptions.decode(c), c) for c in range(1, 20))
+        errors = {ModbusExceptions.decode(c): c for c in range(1, 20)}
         for error, code in iter(errors.items()):
             result = request.doException(code)
             self.assertEqual(str(result), f"Exception Response(129, 1, {error})")
diff --git a/test/test_server_async.py b/test/test_server_async.py
@@ -40,7 +40,7 @@ class AsynchronousServerTest(unittest.TestCase):
     # ----------------------------------------------------------------------- #
     def setUp(self):
         """Initialize the test environment."""
-        values = dict((i, '') for i in range(10))
+        values = {i: '' for i in range(10)}
         ModbusDeviceIdentification(info=values)
 
     def tearDown(self):
diff --git a/test/test_server_context.py b/test/test_server_context.py
@@ -64,7 +64,7 @@ class ModbusServerMultipleContextTest(unittest.TestCase):
 
     def setUp(self):
         """Set up the test environment"""
-        self.slaves = dict((id, ModbusSlaveContext()) for id in range(10))
+        self.slaves = {id: ModbusSlaveContext() for id in range(10)}
         self.context = ModbusServerContext(slaves=self.slaves, single=False)
 
     def tearDown(self):
@@ -94,7 +94,7 @@ def test_multiple_context_default(self):
 
     def test_multiple_context_set(self):
         """Test a setting multiple slave contexts"""
-        slaves = dict((id, ModbusSlaveContext()) for id in range(10))
+        slaves = {id: ModbusSlaveContext() for id in range(10)}
         for slave_id, slave in iter(slaves.items()):
             self.context[slave_id] = slave
         for slave_id, slave in iter(slaves.items()):
diff --git a/test/test_transaction.py b/test/test_transaction.py
@@ -422,7 +422,7 @@ def framer_tls_framer_decode(self):
         result = self._tls.decode_data(msg1)
         self.assertEqual({}, result)
         result = self._tls.decode_data(msg2)
-        self.assertEqual(dict(fcode=1), result)
+        self.assertEqual({'fcode': 1}, result)
         self._tls.advanceFrame()
 
     def framer_tls_incoming_packet(self):
