Merge pull request #589 from DimitriPapadopoulos/ruff

Apply ruff preview rules

Author: FrancescAlted

doc/getting_started/tutorials/09.ucodecs-ufilters.ipynb

@@ -621,9 +621,7 @@
    ],
    "source": [
     "array = blosc2.zeros((30, 30))\n",
-    "array.schunk.cparams = blosc2.CParams(\n",
-    "    **{\"codec\": 184, \"filters\": [filter_id], \"filters_meta\": [0], \"nthreads\": 1}\n",
-    ")\n",
+    "array.schunk.cparams = blosc2.CParams(codec=184, filters=[filter_id], filters_meta=[0], nthreads=1)\n",
     "array.schunk.cparams"
    ]
   }

doc/getting_started/tutorials/10.prefilters.ipynb

@@ -324,7 +324,7 @@
    },
    "outputs": [],
    "source": [
-    "my_schunk.dparams = blosc2.DParams(**{\"nthreads\": 1})  # Disable parallelism for decompression\n",
+    "my_schunk.dparams = blosc2.DParams(nthreads=1)  # Disable parallelism for decompression\n",
     "\n",
     "\n",
     "@my_schunk.postfilter(input_dtype)\n",

src/blosc2/__init__.py

@@ -393,17 +393,21 @@ def _raise(exc):
             "max dimensions": MAX_DIM,
         },
         default_device=lambda: "cpu",
-        default_dtypes=lambda device=None: {
-            "real floating": DEFAULT_FLOAT,
-            "complex floating": DEFAULT_COMPLEX,
-            "integral": DEFAULT_INT,
-            "indexing": DEFAULT_INDEX,
-        }
-        if (device == "cpu" or device is None)
-        else _raise(ValueError("Only cpu devices allowed")),
-        dtypes=lambda device=None, kind=None: np.__array_namespace_info__().dtypes(kind=kind, device=device)
-        if (device == "cpu" or device is None)
-        else _raise(ValueError("Only cpu devices allowed")),
+        default_dtypes=lambda device=None: (
+            {
+                "real floating": DEFAULT_FLOAT,
+                "complex floating": DEFAULT_COMPLEX,
+                "integral": DEFAULT_INT,
+                "indexing": DEFAULT_INDEX,
+            }
+            if (device == "cpu" or device is None)
+            else _raise(ValueError("Only cpu devices allowed"))
+        ),
+        dtypes=lambda device=None, kind=None: (
+            np.__array_namespace_info__().dtypes(kind=kind, device=device)
+            if (device == "cpu" or device is None)
+            else _raise(ValueError("Only cpu devices allowed"))
+        ),
         devices=lambda: ["cpu"],
         name="blosc2",
         version=__version__,

src/blosc2/lazyexpr.py

@@ -115,7 +115,7 @@ def ne_evaluate(expression, local_dict=None, **kwargs):
         if e.args and e.args[0] == "NumExpr 2 does not support Unicode as a dtype.":
             pass
         else:
-            raise e  # unsafe expression
+            raise  # unsafe expression
     except Exception:
         pass
     # Try with blosc2 funcs as presence of non-numexpr funcs probably caused failure
@@ -143,7 +143,7 @@ def ne_evaluate(expression, local_dict=None, **kwargs):
 
 def _get_result(expression, chunk_operands, ne_args, where=None, indices=None, _order=None):
     chunk_indices = None
-    if (expression == "o0" or expression == "(o0)") and where is None:
+    if expression in {"o0", "(o0)"} and where is None:
         # We don't have an actual expression, so avoid a copy except to make contiguous (later)
         return chunk_operands["o0"], None
     # Apply the where condition (in result)
@@ -1750,7 +1750,7 @@ def slices_eval(  # noqa: C901
         # Check whether current cslice intersects with _slice
         cslice = chunk_slice.raw
         nchunk = (
-            builtins.sum([c.start // chunks[i] * np.prod(ratio[i + 1 :]) for i, c in enumerate(cslice)])
+            builtins.sum(c.start // chunks[i] * np.prod(ratio[i + 1 :]) for i, c in enumerate(cslice))
             if 0 not in chunks
             else 0
         )
@@ -2273,7 +2273,7 @@ def reduce_slices(  # noqa: C901
     for chunk_slice in intersecting_chunks:
         cslice = chunk_slice.raw
         nchunk = (
-            builtins.sum([c.start // chunks[i] * np.prod(ratio[i + 1 :]) for i, c in enumerate(cslice)])
+            builtins.sum(c.start // chunks[i] * np.prod(ratio[i + 1 :]) for i, c in enumerate(cslice))
             if 0 not in chunks
             else 0
         )

src/blosc2/ndarray.py

@@ -4352,7 +4352,7 @@ def __getitem__(
 
     def __setitem__(
         self,
-        key: None | int | slice | Sequence[slice | int | np.bool_ | np.ndarray[int | np.bool_] | None],
+        key: int | slice | Sequence[slice | int | np.bool_ | np.ndarray[int | np.bool_] | None] | None,
         value: object,
     ):
         """Set a slice of the array.

src/blosc2/proxy.py

@@ -586,7 +586,7 @@ def _convert_dtype(dt: str | DTypeLike):
     except TypeError:  # likely passed e.g. a torch.float64
         return np.dtype(str(dt).split(".")[1])
     except Exception as e:
-        raise TypeError("Could not parse dtype arg {dt}.") from e
+        raise TypeError(f"Could not parse dtype arg {dt}.") from e
 
 
 class SimpleProxy(blosc2.Operand):
@@ -631,7 +631,7 @@ def is_ints_sequence(src, attr):
         chunks = src.chunks if chunks is None and is_ints_sequence(src, "chunks") else chunks
         blocks = src.blocks if blocks is None and is_ints_sequence(src, "blocks") else blocks
         self.chunks, self.blocks = blosc2.compute_chunks_blocks(
-            self.shape, chunks, blocks, self.dtype, **{"cparams": cparams}
+            self.shape, chunks, blocks, self.dtype, cparams=cparams
         )
 
     @property

src/blosc2/utils.py

@@ -262,7 +262,7 @@ def linalg_shape(func_name, args, kwargs):  # noqa: C901
         axis = 0 if axis is None else axis
         # normalize negative axis
         axis = axis + len(shapes[0]) if axis < 0 else axis
-        concat_dim = builtins.sum([s[axis] for s in shapes])
+        concat_dim = builtins.sum(s[axis] for s in shapes)
         return tuple(s if i != axis else concat_dim for i, s in enumerate(shapes[0]))
 
     # --- diagonal ---
@@ -581,7 +581,7 @@ def visit_Call(self, node):  # noqa : C901
                     return (num,)
                 raise ValueError("linspace requires either shape or num argument")
 
-            elif base_name == "frombuffer" or base_name == "fromiter":
+            elif base_name in {"frombuffer", "fromiter"}:
                 count = kwargs.get("count")
                 return (count,) if count else ()
 
@@ -895,7 +895,7 @@ def _indices(iters):
                 ]
             if nchunk:
                 yield builtins.sum(
-                    [c.start // chunks[i] * np.prod(ratio[i + 1 :]) for i, c in enumerate(my_list)]
+                    c.start // chunks[i] * np.prod(ratio[i + 1 :]) for i, c in enumerate(my_list)
                 )
             else:
                 yield ndindex.Tuple(*my_list)

tests/ndarray/test_copy.py

@@ -55,11 +55,11 @@ def test_values(shape, chunks1, blocks1, chunks2, blocks2, dtype):
     b = a.copy(chunks=chunks2, blocks=blocks2, cparams=cparams2)
     assert a.shape == b.shape
     assert a.schunk.dparams == b.schunk.dparams
-    for key in cparams2:
+    for key, value in cparams2.items():
         if key in ("filters", "filters_meta"):
-            assert getattr(b.schunk.cparams, key)[: len(cparams2[key])] == cparams2[key]
+            assert getattr(b.schunk.cparams, key)[: len(value)] == value
             continue
-        assert getattr(b.schunk.cparams, key) == cparams2[key]
+        assert getattr(b.schunk.cparams, key) == value
     assert b.chunks == tuple(chunks2)
     assert b.blocks == tuple(blocks2)
     assert a.dtype == b.dtype

tests/ndarray/test_elementwise_funcs.py

@@ -105,7 +105,7 @@ def _test_unary_func_impl(np_func, blosc_func, dtype, shape, chunkshape):
             ):
                 assert True
             else:
-                raise e
+                raise
 
 
 def _test_binary_func_proxy(np_func, blosc_func, dtype, shape, chunkshape, xp):
@@ -168,12 +168,12 @@ def _test_binary_func_proxy(np_func, blosc_func, dtype, shape, chunkshape, xp):
             ):  # not supported for complex dtypes
                 assert True
             else:
-                raise e
+                raise
         except NotImplementedError as e:
             if np_func.__name__ in ("left_shift", "right_shift", "floor_divide", "power", "remainder"):
                 assert True
             else:
-                raise e
+                raise
         except AssertionError as e:
             if np_func.__name__ == "power" and blosc2.isdtype(
                 dtype, "integral"
@@ -189,7 +189,7 @@ def _test_binary_func_proxy(np_func, blosc_func, dtype, shape, chunkshape, xp):
                 )
                 pytest.skip("minimum and maximum for numexpr do not match NaN behaviour for numpy")
             else:
-                raise e
+                raise
 
 
 def _test_unary_func_proxy(np_func, blosc_func, dtype, shape, xp):
@@ -228,7 +228,7 @@ def _test_unary_func_proxy(np_func, blosc_func, dtype, shape, xp):
             ):
                 assert True
             else:
-                raise e
+                raise
 
 
 def _test_binary_func_impl(np_func, blosc_func, dtype, shape, chunkshape):
@@ -283,12 +283,12 @@ def _test_binary_func_impl(np_func, blosc_func, dtype, shape, chunkshape):
             ):  # not supported for complex dtypes
                 assert True
             else:
-                raise e
+                raise
         except NotImplementedError as e:
             if np_func.__name__ in ("left_shift", "right_shift", "floor_divide", "power", "remainder"):
                 assert True
             else:
-                raise e
+                raise
         except AssertionError as e:
             if np_func.__name__ == "power" and blosc2.isdtype(
                 dtype, "integral"
@@ -304,7 +304,7 @@ def _test_binary_func_impl(np_func, blosc_func, dtype, shape, chunkshape):
                 )
                 pytest.skip("minimum and maximum for numexpr do not match NaN behaviour for numpy")
             else:
-                raise e
+                raise
 
 
 @pytest.mark.parametrize(("np_func", "blosc_func"), UNARY_FUNC_PAIRS)

tests/ndarray/test_jit.py

@@ -68,7 +68,7 @@ def test_expr_kwargs(sample_data):
     # Testing jit decorator with kwargs
     cparams = blosc2.CParams(clevel=1, codec=blosc2.Codec.LZ4, filters=[blosc2.Filter.BITSHUFFLE])
 
-    @blosc2.jit(**{"cparams": cparams})
+    @blosc2.jit(cparams=cparams)
     def expr_jit_cparams(a, b, c):
         return ((a**3 + np.sin(a * 2)) < c) & (b > 0)