blosc2 3.3.1__tar.gz → 3.3.2__tar.gz

{blosc2-3.3.1 → blosc2-3.3.2}/ANNOUNCE.rst

@@ -1,16 +1,11 @@
-Announcing Python-Blosc2 3.3.1
+Announcing Python-Blosc2 3.3.2
 ==============================
 
-In our effort to better adapt to better adapt to the array API
-(https://data-apis.org/array-api/latest/), we have introduced
-permute_dims() and matrix_transpose() functions, and the .T property.
-This replaces to previous transpose() function, which is now deprecated.
-See PR #384.  Thanks to Ricardo Sales Piquer (@ricardosp4).
-
-We have also reduced the memory footprint of constructors like ``arange()``,
-``linspace()`` and ``fromiter()`` by a large factor. As an example, a 5 TB
-array of 8-byte floats now uses less than 200 MB of memory instead of
-170 GB previously.
+This is a bugfix release, with some minor optimizations.  We fixed
+specially a bug in the determination of chunk shape in constructors
+on CPUs with large L3 cache sizes (like AMD EPYC).  We also fixed a
+bug preventing the correct chaining of *string* lazy expressions for
+logical operators (``&``, ``|``, ``^``...).
 
 You can think of Python-Blosc2 3.x as an extension of NumPy/numexpr that:
 

{blosc2-3.3.1 → blosc2-3.3.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.2
 Name: blosc2
-Version: 3.3.1
+Version: 3.3.2
 Summary: A fast & compressed ndarray library with a flexible compute engine.
 Author-Email: Blosc Development Team <blosc@blosc.org>
 Maintainer-Email: Blosc Development Team <blosc@blosc.org>
@@ -15,12 +15,13 @@ Classifier: Topic :: Software Development :: Libraries :: Python Modules
 Classifier: Operating System :: Microsoft :: Windows
 Classifier: Operating System :: Unix
 Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.10
 Classifier: Programming Language :: Python :: 3.11
 Classifier: Programming Language :: Python :: 3.12
 Classifier: Programming Language :: Python :: 3.13
 Project-URL: homepage, https://github.com/Blosc/python-blosc2
 Project-URL: documentation, https://www.blosc.org/python-blosc2/python-blosc2.html
-Requires-Python: >=3.11
+Requires-Python: >=3.10
 Requires-Dist: numpy>=1.26
 Requires-Dist: ndindex
 Requires-Dist: msgpack

{blosc2-3.3.1 → blosc2-3.3.2}/RELEASE_NOTES.md

@@ -1,5 +1,20 @@
 # Release notes
 
+## Changes from 3.3.1 to 3.3.2
+
+* Fixed a bug in the determination of chunk shape for the `NDArray` constructor.
+  This was causing problems when creating `NDArray` instances with a CPU that
+  was reporting a L3 cache size close (or exceeding) 2 GB.  See PR #392.
+
+* Fixed a bug preventing the correct chaining of *string* lazy expressions for
+  logical operators (`&`, `|`, `^`...).  See PR #391.
+
+* More performance optimization for `blosc2.permute_dims`.  Thanks to
+  Ricardo Sales Piquer (@ricardosp4) for the implementation.
+
+* Now, storage defaults (`blosc2.storage_dflts`) are honored, even if no
+  `storage=` param is used in constructors.
+
 ## Changes from 3.3.0 to 3.3.1
 
 * In our effort to better adapt to better adapt to the array API

{blosc2-3.3.1 → blosc2-3.3.2}/doc/python-blosc2.rst

@@ -6,7 +6,7 @@
 
     <p style="text-align: center; color: black; background-color: rgba(230, 169, 9, 0.65);">
         <a href="https://github.com/Blosc/python-blosc2/blob/main/RELEASE_NOTES.md"
-           style="font-size: 1.5em;">Version 3.3.0 released on 2025-04-08!</a>
+           style="font-size: 1.5em;">Version 3.3.1 released on 2025-04-20!</a>
         <span style="display: inline-block; width: 20px;"></span>
         <span style="font-family: monospace;">pip install blosc2 -U</span>
     </p>

{blosc2-3.3.1 → blosc2-3.3.2}/pyproject.toml

@@ -24,11 +24,12 @@ classifiers = [
     "Operating System :: Microsoft :: Windows",
     "Operating System :: Unix",
     "Programming Language :: Python :: 3",
+    "Programming Language :: Python :: 3.10",
     "Programming Language :: Python :: 3.11",
     "Programming Language :: Python :: 3.12",
     "Programming Language :: Python :: 3.13",
 ]
-requires-python = ">=3.11"
+requires-python = ">=3.10"
 # Follow guidelines from https://scientific-python.org/specs/spec-0000/
 dependencies = [
     "numpy>=1.26",
@@ -40,7 +41,7 @@ dependencies = [
     "py-cpuinfo; platform_machine != 'wasm32'",
     "requests",
 ]
-version = "3.3.1"
+version = "3.3.2"
 
 
 [project.optional-dependencies]

{blosc2-3.3.1 → blosc2-3.3.2}/src/blosc2/core.py

@@ -1322,9 +1322,9 @@ def get_chunksize(blocksize, l3_minimum=4 * 2**20, l3_maximum=2**26):
             if isinstance(l2_cache_size, int) and l3_cache_size > l2_cache_size:
                 chunksize = l3_cache_size
         # When computing expressions, it is convenient to keep chunks for all operands
-        # in L3 cache, so let's divide by 4 (3 operands + result is a typical situation
+        # in L3 cache, so let's divide by 5 (4 operands + result is a typical situation
         # for moderately complex expressions)
-        chunksize //= 4
+        chunksize //= 5
 
     # Chunksize should be at least the size of L2
     l2_cache_size = cpu_info.get("l2_cache_size", "Not found")
@@ -1529,7 +1529,7 @@ def compute_chunks_blocks(  # noqa: C901
             # min_blocksize = blosc2.cpu_info["l1_data_cache_size"] * 4
         elif platform.system() == "Darwin" and "arm" in platform.machine():
             # For Apple Silicon, experiments say we can use 4x the L1 size
-            min_blocksize = blosc2.cpu_info["l1_data_cache_size"] * 2
+            min_blocksize = blosc2.cpu_info["l1_data_cache_size"] * 4
         elif "l1_data_cache_size" in blosc2.cpu_info and isinstance(
             blosc2.cpu_info["l1_data_cache_size"], int
         ):
@@ -1562,6 +1562,11 @@ def compute_chunks_blocks(  # noqa: C901
     if chunks is None:
         blocksize = math.prod(blocks) * itemsize
         chunksize = get_chunksize(blocksize)
+        # Make chunksize to be a multiple of the blocksize. This allows for:
+        # 1. Avoid unnecessary padding in chunks
+        # 2. Avoid exceeding the maximum buffer size (see #392)
+        if chunksize % blocksize != 0:
+            chunksize = chunksize // blocksize * blocksize
         chunks = compute_partition(chunksize // itemsize, shape, blocks)
 
     return tuple(chunks), tuple(blocks)

{blosc2-3.3.1 → blosc2-3.3.2}/src/blosc2/lazyexpr.py

@@ -1481,7 +1481,8 @@ def reduce_slices(  # noqa: C901
             iter_disk = all_ndarray and any_persisted
             # Experiments say that iter_disk is faster than the regular path for reductions
             # even when all operands are in memory, so no need to check any_persisted
-            # New benchs are saying the contrary (> 10% slower), so this needs more investigation
+            # New benchmarks are saying the contrary (> 10% slower), so this needs more
+            # investigation
             # iter_disk = all_ndarray
         else:
             # WebAssembly does not support threading, so we cannot use the iter_disk option
@@ -1919,7 +1920,6 @@ class LazyExpr(LazyArray):
         if hasattr(value2, "_where_args"):
             value2 = value2.compute()
 
-        self._dtype = infer_dtype(op, value1, value2)
         if not isinstance(value1, LazyExpr) and not isinstance(value2, LazyExpr):
             # We converted some of the operands to NDArray (where() handling above)
             new_operands = {"o0": value1, "o1": value2}
@@ -2677,8 +2677,8 @@ class LazyExpr(LazyArray):
             _shape = new_expr.shape
             if isinstance(new_expr, blosc2.LazyExpr):
                 # Restore the original expression and operands
-                new_expr.expression = _expression
-                new_expr.expression_tosave = expression
+                new_expr.expression = f"({_expression})"  # forcibly add parenthesis
+                new_expr.expression_tosave = _expression
                 new_expr.operands = _operands
                 new_expr.operands_tosave = operands
             else:

{blosc2-3.3.1 → blosc2-3.3.2}/src/blosc2/ndarray.py

@@ -3624,17 +3624,22 @@ def asarray(array: np.ndarray | blosc2.C2Array, **kwargs: Any) -> NDArray:
 
 
 def _check_ndarray_kwargs(**kwargs):  # noqa: C901
-    if "storage" in kwargs:
+    storage = kwargs.get("storage")
+    if storage is not None:
         for key in kwargs:
             if key in list(blosc2.Storage.__annotations__):
                 raise AttributeError(
                     "Cannot pass both `storage` and other kwargs already included in Storage"
                 )
-        storage = kwargs.get("storage")
         if isinstance(storage, blosc2.Storage):
             kwargs = {**kwargs, **asdict(storage)}
         else:
             kwargs = {**kwargs, **storage}
+    else:
+        # Add the default storage values as long as they are not already passed
+        storage_dflts = asdict(blosc2.Storage(urlpath=kwargs.get("urlpath")))  # urlpath can affect defaults
+        not_passed = {k: v for k, v in storage_dflts.items() if k not in kwargs}
+        kwargs = {**kwargs, **not_passed}
 
     supported_keys = [
         "chunks",
@@ -3871,11 +3876,11 @@ def matmul(x1: NDArray, x2: NDArray, **kwargs: Any) -> NDArray:
     r = x2.chunks[-1]
 
     for row in range(0, n, p):
-        row_end = (row + p) if (row + p) < n else n
+        row_end = builtins.min(row + p, n)
         for col in range(0, m, q):
-            col_end = (col + q) if (col + q) < m else m
+            col_end = builtins.min(col + q, m)
             for aux in range(0, k, r):
-                aux_end = (aux + r) if (aux + r) < k else k
+                aux_end = builtins.min(aux + r, k)
                 bx1 = x1[row:row_end, aux:aux_end]
                 bx2 = x2[aux:aux_end, col:col_end]
                 result[row:row_end, col:col_end] += np.matmul(bx1, bx2)
@@ -3946,6 +3951,7 @@ def permute_dims(arr: NDArray, axes: tuple[int] | list[int] | None = None, **kwa
            [[13, 14, 15, 16],
             [17, 18, 19, 20],
             [21, 22, 23, 24]]])
+
     >>> at = blosc2.permute_dims(a, axes=(1, 0, 2))
     >>> at[:]
     array([[[ 1,  2,  3,  4],
@@ -3955,37 +3961,39 @@ def permute_dims(arr: NDArray, axes: tuple[int] | list[int] | None = None, **kwa
            [[ 9, 10, 11, 12],
             [21, 22, 23, 24]]])
     """
-
     if np.isscalar(arr) or arr.ndim < 2:
         return arr
 
+    ndim = arr.ndim
+
     if axes is None:
-        axes = range(arr.ndim)[::-1]
+        axes = tuple(range(ndim))[::-1]
     else:
-        axes_transformed = tuple(axis if axis >= 0 else arr.ndim + axis for axis in axes)
-        if sorted(axes_transformed) != list(range(arr.ndim)):
-            raise ValueError(f"axes {axes} is not a valid permutation of {arr.ndim} dimensions")
-        axes = axes_transformed
+        axes = tuple(axis if axis >= 0 else ndim + axis for axis in axes)
+        if sorted(axes) != list(range(ndim)):
+            raise ValueError(f"axes {axes} is not a valid permutation of {ndim} dimensions")
 
     new_shape = tuple(arr.shape[axis] for axis in axes)
-    if "chunks" not in kwargs:
+    if "chunks" not in kwargs or kwargs["chunks"] is None:
         kwargs["chunks"] = tuple(arr.chunks[axis] for axis in axes)
 
     result = blosc2.empty(shape=new_shape, dtype=arr.dtype, **kwargs)
 
-    chunk_slices = [
-        [slice(start, builtins.min(dim, start + chunk)) for start in range(0, dim, chunk)]
-        for dim, chunk in zip(arr.shape, arr.chunks, strict=False)
-    ]
+    chunks = arr.chunks
+    shape = arr.shape
+
+    for info in arr.iterchunks_info():
+        coords = info.coords
+        start_stop = [
+            (coord * chunk, builtins.min(chunk * (coord + 1), dim))
+            for coord, chunk, dim in zip(coords, chunks, shape, strict=False)
+        ]
 
-    block_counts = [len(s) for s in chunk_slices]
-    grid = np.indices(block_counts).reshape(len(block_counts), -1).T
+        src_slice = tuple(slice(start, stop) for start, stop in start_stop)
+        dst_slice = tuple(slice(start_stop[ax][0], start_stop[ax][1]) for ax in axes)
 
-    for idx in grid:
-        block_slices = tuple(chunk_slices[axis][i] for axis, i in enumerate(idx))
-        block = arr[block_slices]
-        target_slices = tuple(block_slices[axis] for axis in axes)
-        result[target_slices] = np.transpose(block, axes=axes).copy()
+        transposed = np.transpose(arr[src_slice], axes=axes)
+        result[dst_slice] = np.ascontiguousarray(transposed)
 
     return result
 
@@ -4019,7 +4027,7 @@ def transpose(x, **kwargs: Any) -> NDArray:
         stacklevel=2,
     )
 
-    # If arguments are dimension < 2 they are returned
+    # If arguments are dimension < 2, they are returned
     if np.isscalar(x) or x.ndim < 2:
         return x
 

blosc2-3.3.2/src/blosc2/version.py

@@ -0,0 +1 @@
+__version__ = "3.3.2"

{blosc2-3.3.1 → blosc2-3.3.2}/tests/ndarray/test_lazyexpr.py

@@ -1220,6 +1220,10 @@ def test_dtype_infer(dtype1, dtype2, scalar):
     np.testing.assert_allclose(res, nres)
     assert res.dtype == nres.dtype
 
+    # Check dtype not changed by expression creation (bug fix)
+    assert a.dtype == dtype1
+    assert b.dtype == dtype2
+
 
 @pytest.mark.parametrize(
     "cfunc", ["np.int8", "np.int16", "np.int32", "np.int64", "np.float32", "np.float64"]
@@ -1323,6 +1327,8 @@ def test_missing_operator():
     assert expr2.operands["a"] is not None
     assert expr2.operands["b"] is None
     # Check that the expression is still there, and can be introspected
+    # Note the added parentheses. The parser automatically adds these,
+    # mainly because of possible operator precedence issues in nested expressions.
     assert expr2.expression == "a + b"
     # Check that dtype and shape are None
     assert expr2.dtype is None
@@ -1330,3 +1336,63 @@ def test_missing_operator():
     # Clean up
     blosc2.remove_urlpath("a.b2nd")
     blosc2.remove_urlpath("expr.b2nd")
+
+
+# Test the chaining of multiple lazy expressions
+def test_chain_expressions():
+    N = 1_000
+    dtype = "float64"
+    a = blosc2.linspace(0, 1, N * N, dtype=dtype, shape=(N, N))
+    b = blosc2.linspace(1, 2, N * N, dtype=dtype, shape=(N, N))
+    c = blosc2.linspace(0, 1, N, dtype=dtype, shape=(N,))
+
+    le1 = a**3 + blosc2.sin(a**2)
+    le2 = le1 < c
+    le3 = le2 & (b < 0)
+    le1_ = blosc2.lazyexpr("a ** 3 + sin(a ** 2)", {"a": a})
+    le2_ = blosc2.lazyexpr("(le1 < c)", {"le1": le1_, "c": c})
+    le3_ = blosc2.lazyexpr("(le2 & (b < 0))", {"le2": le2_, "b": b})
+    assert (le3_[:] == le3[:]).all()
+
+    # TODO: This test should pass eventually
+    # le1 = a ** 3 + blosc2.sin(a ** 2)
+    # le2 = le1 < c
+    # le3 = (b < 0)
+    # le4 = le2 & le3
+    # le1_ = blosc2.lazyexpr("a ** 3 + sin(a ** 2)", {"a": a})
+    # le2_ = blosc2.lazyexpr("(le1 < c)", {"le1": le1_, "c": c})
+    # le3_ = blosc2.lazyexpr("(b < 0)", {"b": b})
+    # le4_ = blosc2.lazyexpr("(le2 & le3)", {"le2": le2_, "le3": le3_})
+    # assert (le4_[:] == le4[:]).all()
+
+
+# TODO: Test the chaining of multiple persistent lazy expressions
+# def test_chain_persistentexpressions():
+#     N = 1_000
+#     dtype = "float64"
+#     a = blosc2.linspace(0, 1, N * N, dtype=dtype, shape=(N, N), urlpath="a.b2nd", mode="w")
+#     b = blosc2.linspace(1, 2, N * N, dtype=dtype, shape=(N, N), urlpath="b.b2nd", mode="w")
+#     c = blosc2.linspace(0, 1, N, dtype=dtype, shape=(N,), urlpath="c.b2nd", mode="w")
+#
+#     le1 = a ** 3 + blosc2.sin(a ** 2)
+#     le2 = le1 < c
+#     le3 = (b < 0)
+#     le4 = le2 & le3
+#
+#     le1_ = blosc2.lazyexpr("a ** 3 + sin(a ** 2)", {"a": a})
+#     le1_.save("expr1.b2nd", mode="w")
+#     myle1 = blosc2.open("expr1.b2nd")
+#
+#     le2_ = blosc2.lazyexpr("(le1 < c)", {"le1": myle1, "c": c})
+#     le2_.save("expr2.b2nd", mode="w")
+#     myle2 = blosc2.open("expr2.b2nd")
+#
+#     le3_ = blosc2.lazyexpr("(b < 0)", {"b": b})
+#     le3_.save("expr3.b2nd", mode="w")
+#     myle3 = blosc2.open("expr3.b2nd")
+#
+#     le4_ = blosc2.lazyexpr("(le2 & le3)", {"le2": myle2, "le3": myle3})
+#     le4_.save("expr4.b2nd", mode="w")
+#     myle4 = blosc2.open("expr4.b2nd")
+#     print((myle4[:] == le4[:]).all())
+#

{blosc2-3.3.1 → blosc2-3.3.2}/tests/ndarray/test_transpose.py

@@ -22,21 +22,22 @@ def dtype_fixture(request):
     params=[
         ((10,), (5,), None),
         ((31,), (14,), (9,)),
+        ((9,), (4,), (3,)),
     ]
 )
-def shape_1d_chunks_blocks(request):
+def shape_chunks_blocks_1d(request):
     return request.param
 
 
 @pytest.fixture(
     params=[
-        ((3, 3), (2, 2), (1, 1)),
+        ((4, 4), (3, 3), (2, 2)),
         ((12, 11), (7, 5), (6, 2)),
-        ((1, 5), (1, 4), (1, 3)),
+        ((6, 5), (5, 4), (4, 3)),
         pytest.param(((51, 603), (22, 99), (13, 29)), marks=pytest.mark.heavy),
     ]
 )
-def shape_2d_chunks_blocks(request):
+def shape_chunks_blocks_2d(request):
     return request.param
 
 
@@ -44,21 +45,21 @@ def shape_2d_chunks_blocks(request):
     params=[
         ((4, 5, 2), (3, 4, 2), (3, 2, 1)),
         ((12, 10, 10), (11, 9, 7), (9, 7, 3)),
-        pytest.param(((37, 63, 55), (12, 5, 41), (10, 5, 11)), marks=pytest.mark.heavy),
+        pytest.param(((37, 63, 55), (12, 30, 41), (10, 5, 11)), marks=pytest.mark.heavy),
     ]
 )
-def shape_3d_chunks_blocks(request):
+def shape_chunks_blocks_3d(request):
     return request.param
 
 
 @pytest.fixture(
     params=[
-        ((3, 3, 5, 7), (2, 3, 2, 4), (1, 1, 1, 4)),
+        ((3, 3, 5, 7), (2, 3, 2, 4), (1, 2, 1, 4)),
         ((4, 6, 5, 2), (3, 3, 4, 2), (3, 2, 2, 1)),
         pytest.param(((10, 10, 10, 11), (7, 8, 9, 11), (6, 7, 8, 5)), marks=pytest.mark.heavy),
     ]
 )
-def shape_4d_chunks_blocks(request):
+def shape_chunks_blocks_4d(request):
     return request.param
 
 
@@ -79,14 +80,13 @@ def shape_4d_chunks_blocks(request):
     },
 )
 def test_scalars(scalar):
-    at = blosc2.permute_dims(scalar)
-    nat = np.transpose(scalar)
-
-    np.testing.assert_allclose(at, nat)
+    scalar_t = blosc2.permute_dims(scalar)
+    np_scalar_t = np.transpose(scalar)
+    np.testing.assert_allclose(scalar_t, np_scalar_t)
 
 
-def test_1d_transpose(shape_1d_chunks_blocks, dtype_fixture):
-    shape, chunks, blocks = shape_1d_chunks_blocks
+def test_1d_permute_dims(shape_chunks_blocks_1d, dtype_fixture):
+    shape, chunks, blocks = shape_chunks_blocks_1d
     a = blosc2.linspace(0, 1, shape=shape, chunks=chunks, blocks=blocks, dtype=dtype_fixture)
     at = blosc2.permute_dims(a)
 
@@ -100,8 +100,8 @@ def test_1d_transpose(shape_1d_chunks_blocks, dtype_fixture):
     "axes",
     list(permutations([0, 1])),
 )
-def test_2d_transpose(shape_2d_chunks_blocks, dtype_fixture, axes):
-    shape, chunks, blocks = shape_2d_chunks_blocks
+def test_2d_permute_dims(shape_chunks_blocks_2d, dtype_fixture, axes):
+    shape, chunks, blocks = shape_chunks_blocks_2d
     a = blosc2.linspace(0, 1, shape=shape, chunks=chunks, blocks=blocks, dtype=dtype_fixture)
     at = blosc2.permute_dims(a, axes=axes)
 
@@ -115,8 +115,8 @@ def test_2d_transpose(shape_2d_chunks_blocks, dtype_fixture, axes):
     "axes",
     list(permutations([0, 1, 2])),
 )
-def test_3d_transpose(shape_3d_chunks_blocks, dtype_fixture, axes):
-    shape, chunks, blocks = shape_3d_chunks_blocks
+def test_3d_permute_dims(shape_chunks_blocks_3d, dtype_fixture, axes):
+    shape, chunks, blocks = shape_chunks_blocks_3d
     a = blosc2.linspace(0, 1, shape=shape, chunks=chunks, blocks=blocks, dtype=dtype_fixture)
     at = blosc2.permute_dims(a, axes=axes)
 
@@ -130,8 +130,8 @@ def test_3d_transpose(shape_3d_chunks_blocks, dtype_fixture, axes):
     "axes",
     list(permutations([0, 1, 2, 3])),
 )
-def test_4d_transpose(shape_4d_chunks_blocks, dtype_fixture, axes):
-    shape, chunks, blocks = shape_4d_chunks_blocks
+def test_4d_permute_dims(shape_chunks_blocks_4d, dtype_fixture, axes):
+    shape, chunks, blocks = shape_chunks_blocks_4d
     a = blosc2.linspace(0, 1, shape=shape, chunks=chunks, blocks=blocks, dtype=dtype_fixture)
     at = blosc2.permute_dims(a, axes=axes)
 
@@ -150,8 +150,8 @@ def test_4d_transpose(shape_4d_chunks_blocks, dtype_fixture, axes):
     "dtype",
     {np.complex64, np.complex128},
 )
-def test_complex(shape_3d_chunks_blocks, dtype, axes):
-    shape, chunks, blocks = shape_3d_chunks_blocks
+def test_complex(shape_chunks_blocks_3d, dtype, axes):
+    shape, chunks, blocks = shape_chunks_blocks_3d
     real_part = blosc2.linspace(0, 1, shape=shape, chunks=chunks, blocks=blocks, dtype=dtype)
     imag_part = blosc2.linspace(1, 0, shape=shape, chunks=chunks, blocks=blocks, dtype=dtype)
     complex_matrix = real_part + 3j * imag_part
@@ -176,8 +176,8 @@ def test_complex(shape_3d_chunks_blocks, dtype, axes):
         (0, -4, 1),
     ],
 )
-def test_invalid_axes_raises(shape_3d_chunks_blocks, axes):
-    shape, chunks, blocks = shape_3d_chunks_blocks
+def test_invalid_axes_raises(shape_chunks_blocks_3d, axes):
+    shape, chunks, blocks = shape_chunks_blocks_3d
     a = blosc2.linspace(0, 1, shape=shape, chunks=chunks, blocks=blocks)
 
     with pytest.raises(ValueError, match="not a valid permutation"):
@@ -186,11 +186,7 @@ def test_invalid_axes_raises(shape_3d_chunks_blocks, axes):
 
 @pytest.mark.parametrize(
     "shape",
-    [
-        (2, 3),
-        (4, 5, 6),
-        (2, 4, 8, 5),
-    ],
+    [(2, 3), (4, 5, 6), (2, 4, 8, 5), (7, 3, 9, 9, 5)],
 )
 def test_matrix_transpose(shape):
     arr = blosc2.linspace(0, 1, shape=shape)
@@ -223,13 +219,12 @@ def test_disk():
     nc = np.transpose(na)
 
     np.testing.assert_allclose(c, nc, rtol=1e-6)
-
     blosc2.remove_urlpath("a_test.b2nd")
     blosc2.remove_urlpath("c_test.b2nd")
 
 
-def test_transpose(shape_2d_chunks_blocks, dtype_fixture):
-    shape, chunks, blocks = shape_2d_chunks_blocks
+def test_transpose(shape_chunks_blocks_2d, dtype_fixture):
+    shape, chunks, blocks = shape_chunks_blocks_2d
     a = blosc2.linspace(0, 1, shape=shape, chunks=chunks, blocks=blocks, dtype=dtype_fixture)
     with pytest.warns(DeprecationWarning):
         at = blosc2.transpose(a)

blosc2-3.3.1/src/blosc2/version.py

@@ -1 +0,0 @@
-__version__ = "3.3.1"