Enforce ruff/flake8-comprehensions rules (C4) (#605)

* Apply ruff/flake8-comprehensions rule C401

C401 Unnecessary generator (rewrite as a `set` comprehension)

* Apply ruff/flake8-comprehensions rules C408

C408 Unnecessary `dict` call (rewrite as a literal)

* Enforce ruff/flake8-comprehensions rules (C4)

---------

Co-authored-by: David Stansby <[email protected]>

Author: DimitriPapadopoulos

numcodecs/abc.py

@@ -84,7 +84,7 @@ def get_config(self):
         # override in sub-class if need special encoding of config values
 
         # setup config object
-        config = dict(id=self.codec_id)
+        config = {'id': self.codec_id}
 
         # by default, assume all non-private members are configuration
         # parameters - override this in sub-class if not the case

numcodecs/categorize.py

@@ -85,12 +85,12 @@ def decode(self, buf, out=None):
         return dec
 
     def get_config(self):
-        config = dict(
-            id=self.codec_id,
-            labels=self.labels,
-            dtype=self.dtype.str,
-            astype=self.astype.str,
-        )
+        config = {
+            'id': self.codec_id,
+            'labels': self.labels,
+            'dtype': self.dtype.str,
+            'astype': self.astype.str,
+        }
         return config
 
     def __repr__(self):

numcodecs/delta.py

@@ -91,7 +91,7 @@ def decode(self, buf, out=None):
 
     def get_config(self):
         # override to handle encoding dtypes
-        return dict(id=self.codec_id, dtype=self.dtype.str, astype=self.astype.str)
+        return {'id': self.codec_id, 'dtype': self.dtype.str, 'astype': self.astype.str}
 
     def __repr__(self):
         r = f'{type(self).__name__}(dtype={self.dtype.str!r}'

numcodecs/fixedscaleoffset.py

@@ -116,13 +116,13 @@ def decode(self, buf, out=None):
 
     def get_config(self):
         # override to handle encoding dtypes
-        return dict(
-            id=self.codec_id,
-            scale=self.scale,
-            offset=self.offset,
-            dtype=self.dtype.str,
-            astype=self.astype.str,
-        )
+        return {
+            'id': self.codec_id,
+            'scale': self.scale,
+            'offset': self.offset,
+            'dtype': self.dtype.str,
+            'astype': self.astype.str,
+        }
 
     def __repr__(self):
         r = f'{type(self).__name__}(scale={self.scale}, offset={self.offset}, dtype={self.dtype.str!r}'

numcodecs/json.py

@@ -52,17 +52,17 @@ def __init__(
             else:
                 separators = ', ', ': '
         separators = tuple(separators)
-        self._encoder_config = dict(
-            skipkeys=skipkeys,
-            ensure_ascii=ensure_ascii,
-            check_circular=check_circular,
-            allow_nan=allow_nan,
-            indent=indent,
-            separators=separators,
-            sort_keys=sort_keys,
-        )
+        self._encoder_config = {
+            'skipkeys': skipkeys,
+            'ensure_ascii': ensure_ascii,
+            'check_circular': check_circular,
+            'allow_nan': allow_nan,
+            'indent': indent,
+            'separators': separators,
+            'sort_keys': sort_keys,
+        }
         self._encoder = _json.JSONEncoder(**self._encoder_config)
-        self._decoder_config = dict(strict=strict)
+        self._decoder_config = {'strict': strict}
         self._decoder = _json.JSONDecoder(**self._decoder_config)
 
     def encode(self, buf):
@@ -89,7 +89,7 @@ def decode(self, buf, out=None):
             return dec
 
     def get_config(self):
-        config = dict(id=self.codec_id, encoding=self._text_encoding)
+        config = {'id': self.codec_id, 'encoding': self._text_encoding}
         config.update(self._encoder_config)
         config.update(self._decoder_config)
         return config

numcodecs/msgpacks.py

@@ -75,12 +75,12 @@ def decode(self, buf, out=None):
             return dec
 
     def get_config(self):
-        return dict(
-            id=self.codec_id,
-            raw=self.raw,
-            use_single_float=self.use_single_float,
-            use_bin_type=self.use_bin_type,
-        )
+        return {
+            'id': self.codec_id,
+            'raw': self.raw,
+            'use_single_float': self.use_single_float,
+            'use_bin_type': self.use_bin_type,
+        }
 
     def __repr__(self):
         return f'MsgPack(raw={self.raw!r}, use_bin_type={self.use_bin_type!r}, use_single_float={self.use_single_float!r})'

numcodecs/pickles.py

@@ -49,7 +49,7 @@ def decode(self, buf, out=None):
             return dec
 
     def get_config(self):
-        return dict(id=self.codec_id, protocol=self.protocol)
+        return {'id': self.codec_id, 'protocol': self.protocol}
 
     def __repr__(self):
         return f'Pickle(protocol={self.protocol})'

numcodecs/quantize.py

@@ -85,12 +85,12 @@ def decode(self, buf, out=None):
 
     def get_config(self):
         # override to handle encoding dtypes
-        return dict(
-            id=self.codec_id,
-            digits=self.digits,
-            dtype=self.dtype.str,
-            astype=self.astype.str,
-        )
+        return {
+            'id': self.codec_id,
+            'digits': self.digits,
+            'dtype': self.dtype.str,
+            'astype': self.astype.str,
+        }
 
     def __repr__(self):
         r = f'{type(self).__name__}(digits={self.digits}, dtype={self.dtype.str!r}'

numcodecs/tests/test_blosc.py

@@ -199,12 +199,12 @@ def test_config_blocksize():
     # explicitly stated
 
     # blocksize not stated
-    config = dict(cname='lz4', clevel=1, shuffle=Blosc.SHUFFLE)
+    config = {"cname": 'lz4', "clevel": 1, "shuffle": Blosc.SHUFFLE}
     codec = Blosc.from_config(config)
     assert codec.blocksize == 0
 
     # blocksize stated
-    config = dict(cname='lz4', clevel=1, shuffle=Blosc.SHUFFLE, blocksize=2**8)
+    config = {"cname": 'lz4', "clevel": 1, "shuffle": Blosc.SHUFFLE, "blocksize": 2**8}
     codec = Blosc.from_config(config)
     assert codec.blocksize == 2**8
 

numcodecs/tests/test_lzma.py

@@ -29,7 +29,7 @@
     LZMA(preset=1),
     LZMA(preset=5),
     LZMA(preset=9),
-    LZMA(format=_lzma.FORMAT_RAW, filters=[dict(id=_lzma.FILTER_LZMA2, preset=1)]),
+    LZMA(format=_lzma.FORMAT_RAW, filters=[{"id": _lzma.FILTER_LZMA2, "preset": 1}]),
 ]