Keep ruff happy

Author: FrancescAlted

Diff for: examples/ndarray/jit-expr.py

@@ -9,14 +9,17 @@
 # Examples of using the jit decorator with expressions
 # You can find benchmarks for this example in the bench/ndarray directory
 
-import blosc2
 import numpy as np
 
+import blosc2
+
+
 # Example 1: Basic usage of the jit decorator
 @blosc2.jit
 def expr_jit(a, b, c):
     # This function computes a boolean array where the condition is met
-    return ((a ** 3 + np.sin(a * 2)) < c) & (b > 0)
+    return ((a**3 + np.sin(a * 2)) < c) & (b > 0)
+
 
 # Create some sample data
 a = blosc2.linspace(0, 1, 10 * 100, dtype="float32", shape=(10, 100))
@@ -25,29 +28,33 @@ def expr_jit(a, b, c):
 
 # Call the function with the jit decorator
 result = expr_jit(a, b, c)
-print(result[1,:10])
+print(result[1, :10])
 
 # Example 2: Using the jit decorator with an out parameter
 out = blosc2.zeros((10, 100), dtype=np.bool_)
 
+
 @blosc2.jit(out=out)
 def expr_jit_out(a, b, c):
     # This function computes a boolean array and stores the result in the 'out' array
-    return ((a ** 3 + np.sin(a * 2)) < c) & (b > 0)
+    return ((a**3 + np.sin(a * 2)) < c) & (b > 0)
+
 
 # Call the function with the jit decorator and out parameter
 result_out = expr_jit_out(a, b, c)
-print(result_out[1,:10])
-print(out[1,:10])  # The 'out' array should now contain the same result
+print(result_out[1, :10])
+print(out[1, :10])  # The 'out' array should now contain the same result
 
 # Example 3: Using the jit decorator with additional keyword arguments
 cparams = blosc2.CParams(clevel=1, codec=blosc2.Codec.LZ4, filters=[blosc2.Filter.BITSHUFFLE])
 
+
 @blosc2.jit(cparams=cparams)
 def expr_jit_cparams(a, b, c):
     # This function computes a boolean array with custom compression parameters
-    return ((a ** 3 + np.sin(a * 2)) < c) & (b > 0)
+    return ((a**3 + np.sin(a * 2)) < c) & (b > 0)
+
 
 # Call the function with the jit decorator and custom parameters
 result_cparams = expr_jit_cparams(a, b, c)
-print(result_cparams[1,:10])
+print(result_cparams[1, :10])

Diff for: examples/ndarray/jit-reduc.py

@@ -9,14 +9,17 @@
 # Examples of using the jit decorator with reductions
 # You can find benchmarks for this example in the bench/ndarray directory
 
-import blosc2
 import numpy as np
 
+import blosc2
+
+
 # Example 1: Basic usage of the jit decorator with reduction
 @blosc2.jit
 def expr_jit(a, b, c):
     # This function computes a sum reduction along axis 1
-    return np.sum(((a ** 3 + np.sin(a * 2)) < c) & (b > 0), axis=1)
+    return np.sum(((a**3 + np.sin(a * 2)) < c) & (b > 0), axis=1)
+
 
 # Create some sample data
 a = blosc2.linspace(0, 1, 10 * 100, dtype="float32", shape=(10, 100))
@@ -30,10 +33,12 @@ def expr_jit(a, b, c):
 # Example 2: Using the jit decorator with an out parameter for reduction
 out = np.zeros((10,), dtype=np.int64)
 
+
 @blosc2.jit
 def expr_jit_out(a, b, c):
     # This function computes a sum reduction along axis 1 and stores the result in the 'out' array
-    return np.sum(((a ** 3 + np.sin(a * 2)) < c) & (b > 0), axis=1, out=out)
+    return np.sum(((a**3 + np.sin(a * 2)) < c) & (b > 0), axis=1, out=out)
+
 
 # Call the function with the jit decorator and out parameter
 result_out = expr_jit_out(a, b, c)
@@ -44,10 +49,12 @@ def expr_jit_out(a, b, c):
 cparams = blosc2.CParams(clevel=1, codec=blosc2.Codec.LZ4, filters=[blosc2.Filter.BITSHUFFLE])
 out_cparams = blosc2.zeros((10,), dtype=np.int64, cparams=cparams)
 
+
 @blosc2.jit
 def expr_jit_cparams(a, b, c):
     # This function computes a sum reduction along axis 1 with custom compression parameters
-    return np.sum(((a ** 3 + np.sin(a * 2)) < c) & (b > 0), axis=1, out=out_cparams)
+    return np.sum(((a**3 + np.sin(a * 2)) < c) & (b > 0), axis=1, out=out_cparams)
+
 
 # Call the function with the jit decorator and custom parameters
 result_cparams = expr_jit_cparams(a, b, c)

Diff for: tests/ndarray/test_jit.py

@@ -6,20 +6,27 @@
 # LICENSE file in the root directory of this source tree)
 #######################################################################
 
+import numpy as np
 import pytest
 
 import blosc2
 
-import numpy as np
-
 ###### General expressions
 
 # Define the parameters
 test_params = [
-    ((10, 100), (10, 100,), "float32"),
+    (
+        (10, 100),
+        (
+            10,
+            100,
+        ),
+        "float32",
+    ),
     ((10, 100), (100,), "float64"),  # using broadcasting
 ]
 
+
 @pytest.fixture(params=test_params)
 def sample_data(request):
     shape, cshape, dtype = request.param
@@ -29,12 +36,15 @@ def sample_data(request):
     c = blosc2.linspace(-10, 10, cshape[0], dtype=dtype, shape=cshape)
     return a, b, c, shape, cshape, dtype
 
+
 def expr_nojit(a, b, c):
-    return ((a ** 3 + np.sin(a * 2)) < c) & (b > 0)
+    return ((a**3 + np.sin(a * 2)) < c) & (b > 0)
+
 
 @blosc2.jit
 def expr_jit(a, b, c):
-    return ((a ** 3 + np.sin(a * 2)) < c) & (b > 0)
+    return ((a**3 + np.sin(a * 2)) < c) & (b > 0)
+
 
 def test_expr(sample_data):
     a, b, c, shape, cshape, dtype = sample_data
@@ -52,12 +62,13 @@ def test_expr_out(sample_data):
 
     @blosc2.jit(out=out)
     def expr_jit_out(a, b, c):
-        return ((a ** 3 + np.sin(a * 2)) < c) & (b > 0)
+        return ((a**3 + np.sin(a * 2)) < c) & (b > 0)
 
     d_jit = expr_jit_out(a, b, c)
     np.testing.assert_equal(d_jit[...], d_nojit[...])
     np.testing.assert_equal(out[...], d_nojit[...])
 
+
 def test_expr_kwargs(sample_data):
     a, b, c, shape, cshape, dtype = sample_data
     d_nojit = expr_nojit(a, b, c)
@@ -67,7 +78,7 @@ def test_expr_kwargs(sample_data):
 
     @blosc2.jit(**{"cparams": cparams})
     def expr_jit_cparams(a, b, c):
-        return ((a ** 3 + np.sin(a * 2)) < c) & (b > 0)
+        return ((a**3 + np.sin(a * 2)) < c) & (b > 0)
 
     d_jit = expr_jit_cparams(a, b, c)
     np.testing.assert_equal(d_jit[...], d_nojit[...])
@@ -78,12 +89,15 @@ def expr_jit_cparams(a, b, c):
 
 ###### Reductions
 
+
 def reduc_nojit(a, b, c):
-    return np.sum(((a ** 3 + np.sin(a * 2)) < c) & (b > 0), axis=1)
+    return np.sum(((a**3 + np.sin(a * 2)) < c) & (b > 0), axis=1)
+
 
 @blosc2.jit
 def reduc_jit(a, b, c):
-    return np.sum(((a ** 3 + np.sin(a * 2)) < c) & (b > 0), axis=1)
+    return np.sum(((a**3 + np.sin(a * 2)) < c) & (b > 0), axis=1)
+
 
 def test_reduc(sample_data):
     a, b, c, shape, cshape, dtype = sample_data
@@ -93,6 +107,7 @@ def test_reduc(sample_data):
 
     np.testing.assert_equal(d_jit[...], d_nojit[...])
 
+
 def test_reduc_out(sample_data):
     a, b, c, shape, cshape, dtype = sample_data
     d_nojit = reduc_nojit(a, b, c)
@@ -103,12 +118,13 @@ def test_reduc_out(sample_data):
     # Note that out does not work with reductions as the last function call
     @blosc2.jit
     def reduc_jit_out(a, b, c):
-        return np.sum(((a ** 3 + np.sin(a * 2)) < c) & (b > 0), axis=1, out=out)
+        return np.sum(((a**3 + np.sin(a * 2)) < c) & (b > 0), axis=1, out=out)
 
     d_jit = reduc_jit_out(a, b, c)
     np.testing.assert_equal(d_jit[...], d_nojit[...])
     np.testing.assert_equal(out[...], d_nojit[...])
 
+
 def test_reduc_kwargs(sample_data):
     a, b, c, shape, cshape, dtype = sample_data
     d_nojit = reduc_nojit(a, b, c)
@@ -119,7 +135,7 @@ def test_reduc_kwargs(sample_data):
 
     @blosc2.jit
     def reduc_jit_cparams(a, b, c):
-        return np.sum(((a ** 3 + np.sin(a * 2)) < c) & (b > 0), axis=1, out=out)
+        return np.sum(((a**3 + np.sin(a * 2)) < c) & (b > 0), axis=1, out=out)
 
     d_jit = reduc_jit_cparams(a, b, c)
     np.testing.assert_equal(d_jit[...], d_nojit[...])

Diff for: tests/ndarray/test_lazyexpr_fields.py

@@ -344,7 +344,7 @@ def test_where_reduction1(array_fixture):
 def test_where_reduction2(array_fixture):
     sa1, sa2, nsa1, nsa2, a1, a2, a3, a4, na1, na2, na3, na4 = array_fixture
     # We have to use the original names in fields here
-    expr = sa1[f"(b * a.sum()) > 0"]
+    expr = sa1["(b * a.sum()) > 0"]
     res = expr[:]
     nres = nsa1[(na2 * na1.sum()) > 0]
     # On general chunked ndim arrays, we cannot guarantee the order of the results