blosc2 3.2.1__tar.gz → 3.3.0__tar.gz

{blosc2-3.2.1 → blosc2-3.3.0}/.pre-commit-config.yaml

@@ -16,7 +16,7 @@ repos:
       - id: trailing-whitespace
 
   - repo: https://github.com/astral-sh/ruff-pre-commit
-    rev: v0.9.9
+    rev: v0.11.4
     hooks:
       - id: ruff
         args: ["--fix", "--show-fixes"]

{blosc2-3.2.1 → blosc2-3.3.0}/ANNOUNCE.rst

@@ -1,16 +1,12 @@
-Announcing Python-Blosc2 3.2.1
+Announcing Python-Blosc2 3.3.0
 ==============================
 
-Here, all array containers in Blosc2 implement the ``__array_interface__``
-protocol to expose the data in the array.  This allows for better
-interoperability with other libraries like NumPy, CuPy, etc.  Now, the range
-of functions spans to most of NumPy functions, including reductions.
+We are introducing a new blosc2.transpose() function for natively transposing
+2D NDArray instances and a fast path for NDArray.slice() that delivers up to
+40x speedup when slices align with underlying chunks. Documentation has also
+been improved with several edits throughout.
 
-See examples at: https://github.com/Blosc/python-blosc2/blob/main/examples/ndarray/jit-numpy-funcs.py
-See benchmarks at: https://github.com/Blosc/python-blosc2/blob/main/bench/ndarray/jit-numpy-funcs.py
-
-We have also improved the performance of constructors like ``blosc2.linspace()``
-or ``blosc2.arange()`` by a factor of up to 3x for large arrays.
+See benchmarks at: https://github.com/Blosc/python-blosc2/blob/main/bench/ndarray/aligned_chunks.py
 
 You can think of Python-Blosc2 3.x as an extension of NumPy/numexpr that:
 

{blosc2-3.2.1 → blosc2-3.3.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.2
 Name: blosc2
-Version: 3.2.1
+Version: 3.3.0
 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>
@@ -166,6 +166,7 @@ to the core development of the Blosc2 library:
 - Juan David Ibáñez
 - Ivan Vilata i Balaguer
 - Oumaima Ech.Chdig
+- Ricardo Sales Piquer
 
 In addition, other people have participated to the project in different
 aspects:

{blosc2-3.2.1 → blosc2-3.3.0}/README.rst

@@ -108,6 +108,7 @@ to the core development of the Blosc2 library:
 - Juan David Ibáñez
 - Ivan Vilata i Balaguer
 - Oumaima Ech.Chdig
+- Ricardo Sales Piquer
 
 In addition, other people have participated to the project in different
 aspects:

{blosc2-3.2.1 → blosc2-3.3.0}/RELEASE_NOTES.md

@@ -1,5 +1,23 @@
 # Release notes
 
+## Changes from 3.2.1 to 3.3.0
+
+* New `blosc2.transpose()` function for transposing 2D NDArray instances
+  natively. See PR #375 and docs at
+  https://www.blosc.org/python-blosc2/reference/autofiles/operations_with_arrays/blosc2.transpose.html#blosc2.transpose
+  Thanks to Ricardo Sales Piquer (@ricardosp4) for the implementation.
+
+* New fast path for `NDArray.slice()` for getting slices that are aligned with
+  underlying chunks. This is a common operation when working with NDArray
+  instances, and now it is up to 40x faster in our benchmarks (see PR #380).
+
+* Returned `NDArray` object in `NDarray.slice()` now defaults to original
+  codec/clevel/filters. The previous behavior was to use the default
+  codec/clevel/filters.  See PR #378.  Thanks to Luke Shaw (@lshaw8317).
+
+* Several English edits in the documentation.  Thanks to Luke Shaw (@lshaw8317)
+  for his help in this area.
+
 ## Changes from 3.2.0 to 3.2.1
 
 * The array containers are now using the `__array_interface__` protocol to

{blosc2-3.2.1 → blosc2-3.3.0}/doc/getting_started/tutorials/05.persistent-reductions.ipynb

@@ -25,7 +25,7 @@
    "source": [
     "## Operands as arrays of different shape\n",
     "\n",
-    "We will now create the operands, using different shape for each of them, just for flexing the broadcasting capabilities of lazy expressions."
+    "We will now create the operands, using a different shape for each of them, in order to flex the broadcasting capabilities of lazy expressions."
    ]
   },
   {
@@ -77,7 +77,7 @@
    "source": [
     "## Creating, saving and loading a lazy expression\n",
     "\n",
-    "First, let's build a string expression that sums the contents of array `a` and operates with the values of `b` by `c`. In this context, creating a string version of the expression is critical; otherwise, reductions should be computed eagerly.\n",
+    "First, let's build a string expression that sums the contents of array `a` and performs a multiplication with `b` and `c`. In this context, creating a string version of the expression is critical; otherwise, reductions will be computed eagerly.\n",
     "\n",
     "Let's see how this works."
    ]
@@ -110,13 +110,13 @@
    "id": "6226bf8d46ac7c32",
    "metadata": {},
    "source": [
-    "In the code above, an expression combining the arrays `a`, `b`, and `c` is expressed in string form: `a.sum() + b ∗ c`.  Then, one builds a lazy expression and save it for later. The expression chosen illustrates how operations automatically adapt to the dimensions of the operands through the concept of broadcasting.\n",
+    "In the code above, an expression combining the arrays `a`, `b`, and `c` is expressed in string form: `a.sum() + b ∗ c`.  Then, one builds a lazy expression and saves it for later. The chosen expression illustrates how operations automatically adapt to the dimensions of the operands via broadcasting.\n",
     "\n",
-    "**Broadcasting** allows arrays of different shapes (dimensions) to align for mathematical operations, such as addition or multiplication, without the need to enlarge operands by replicating data. The main idea is that smaller dimensions are \"stretched\" to larger dimensions in such a way that allows the operation to be performed consistently.\n",
+    "**Broadcasting** allows arrays of different shapes (dimensions) to align for mathematical operations, such as addition or multiplication, without the need to enlarge operands by replicating data. The main idea is that smaller dimensions are \"stretched\" to larger dimensions in such a way that the operation may be performed consistently.\n",
     "\n",
     "<img src=\"images/lazyexpr-broadcast.png\" width=\"1000\"/>\n",
     "\n",
-    "See [NumPy docs on broadcasting](https://numpy.org/doc/stable/user/basics.broadcasting.html) for more information.\n",
+    "See the [NumPy docs on broadcasting](https://numpy.org/doc/stable/user/basics.broadcasting.html) for more information.\n",
     "\n",
     "Now that we have saved the expression, we can open and compute it to obtain the result. Let's see how this is done."
    ]
@@ -167,7 +167,7 @@
    "id": "362cfd5eb88b9bb6",
    "metadata": {},
    "source": [
-    "As we can observe when printing the lazy expression and its shape, the time required to get the `shape` is significantly shorter. This is because `lazy_expression.shape` does not need to compute all the elements of the expression; instead, it only accesses the **metadata** of the operands, from which it is inferred the basic information about the dimensions and type of the result.\n",
+    "As we can observe when printing the lazy expression and its shape, the time required to get the `shape` is significantly shorter. This is because `lazy_expression.shape` does not need to compute all the elements of the expression; instead, it only accesses the **metadata** of the operands, from which it infers the necessary information about the dimensions and type of the result.\n",
     "\n",
     "Thanks to this metadata, if we know the dimensions of the arrays involved in the operation (such as in the case of `a.sum() + b * c`), Blosc2 can **quickly infer the resulting shape** without performing intensive calculations. This allows for fast access to structural information (like the `shape` and `dtype`) without operating on the actual data.\n",
     "\n",
@@ -181,7 +181,7 @@
    "source": [
     "## Resizing operands of persisted lazy expressions\n",
     "\n",
-    "In this section, we will see how persisted lazy expressions automatically adapt to changes in the dimensions and values of the original operands, such as arrays `a` and `b`."
+    "In this section, we will see how persisted lazy expressions automatically adapt to changes in the dimensions and values of the original operands, such as the arrays `a` and `b`."
    ]
   },
   {
@@ -233,7 +233,7 @@
    "id": "d82492bf518c5a39",
    "metadata": {},
    "source": [
-    "After increasing the dimensions of the original arrays by modifying the values of `a` and `b`, the lazy expression is reopened. This step is crucial as it allows us to observe how the computation of the expression adapts to the new dimensions. Upon re-opening the expression, we can check that the results now accurately reflect these changes in the dimensions of the array operands. Moreover, see how obtaining the structural information (the `shape`) of the expression is a quick process, requiring only a fraction of the time it takes for the complete computation.\n",
+    "After increasing the dimensions of the original arrays by modifying the values of `a` and `b`, the lazy expression is reopened. This step is crucial as it allows us to observe how the computation of the expression adapts to the new dimensions. Upon re-opening the expression, we can check that the results now accurately reflect these changes in the dimensions of the array operands. Moreover, see how obtaining the updated structural information (the `shape`) of the expression is a quick process, requiring only a fraction of the time it takes for the complete computation.\n",
     "\n",
     "This behavior highlights the ability of lazy expressions to adjust to operands using **metadata**, eliminating the need to re-compute each operation from the beginning. Thanks to this approach, notable flexibility and efficiency are achieved in handling arrays of various shapes and sizes."
    ]
@@ -249,7 +249,7 @@
     "\n",
     "Also, broadcasting support facilitates working with arrays of different sizes, making the process more powerful and intuitive.\n",
     "\n",
-    "Understanding how operations are managed in this context enables developers and data scientists to make the most of reduction and broadcasting capabilities, thereby enhancing the efficiency and effectiveness of their analyses and calculations. The beauty of lazy expressions lies in its ability to simplify the complex and empower our creativity!"
+    "Understanding how operations are managed in this context enables developers and data scientists to make the most of reduction and broadcasting capabilities, thereby enhancing the efficiency and effectiveness of their analyses and calculations. The beauty of lazy expressions lies in their ability to simplify the complex and empower our creativity!"
    ]
   },
   {

{blosc2-3.2.1 → blosc2-3.3.0}/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.2.0 released on 2025-02-27!</a>
+           style="font-size: 1.5em;">Version 3.2.1 released on 2025-04-27!</a>
         <span style="display: inline-block; width: 20px;"></span>
         <span style="font-family: monospace;">pip install blosc2 -U</span>
     </p>

{blosc2-3.2.1 → blosc2-3.3.0}/doc/reference/linear_algebra.rst

@@ -12,3 +12,4 @@ The next functions can be used for computing linear algebra operations with :ref
    :nosignatures:
 
     matmul
+    transpose

{blosc2-3.2.1 → blosc2-3.3.0}/pyproject.toml

@@ -40,7 +40,7 @@ dependencies = [
     "py-cpuinfo; platform_machine != 'wasm32'",
     "requests",
 ]
-version = "3.2.1"
+version = "3.3.0"
 
 
 [project.optional-dependencies]

{blosc2-3.2.1 → blosc2-3.3.0}/src/blosc2/__init__.py

@@ -248,6 +248,7 @@ from .ndarray import (
     full,
     save,
     matmul,
+    transpose,
 )
 
 from .c2array import c2context, C2Array, URLPath

{blosc2-3.2.1 → blosc2-3.3.0}/src/blosc2/ndarray.py

@@ -13,6 +13,7 @@ import inspect
 import math
 from collections import OrderedDict, namedtuple
 from functools import reduce
+from itertools import product
 from typing import TYPE_CHECKING, Any, NamedTuple
 
 from numpy.exceptions import ComplexWarning
@@ -1029,6 +1030,82 @@ def extract_values(arr, indices: np.ndarray[np.int_], max_cache_size: int = 10)
     return extracted_values
 
 
+def detect_aligned_chunks(  # noqa: C901
+    key: Sequence[slice], shape: Sequence[int], chunks: Sequence[int], consecutive: bool = False
+) -> list[int]:
+    """
+    Detect whether a multidimensional slice is aligned with chunk boundaries.
+
+    Parameters
+    ----------
+    key : Sequence of slice
+        The multidimensional slice to check.
+    shape : Sequence of int
+        Shape of the NDArray.
+    chunks : Sequence of int
+        Chunk shape of the NDArray.
+    consecutive : bool, default=False
+        If True, check if the chunks are consecutive in storage order.
+        If False, only check for chunk boundary alignment.
+
+    Returns
+    -------
+    list[int]
+        List of chunk indices (in C-order) that the slice overlaps with.
+        If the slice isn't aligned with chunk boundaries, returns an empty list.
+        If consecutive=True and chunks aren't consecutive, returns an empty list.
+    """
+    if len(key) != len(shape):
+        return []
+
+    # Check that slice boundaries are exact multiple of chunk boundaries
+    for i, s in enumerate(key):
+        if s.start is not None and s.start % chunks[i] != 0:
+            return []
+        if s.stop is not None and s.stop % chunks[i] != 0:
+            return []
+
+    # Parse the slice boundaries
+    start_indices = []
+    end_indices = []
+    n_chunks = []
+
+    for i, s in enumerate(key):
+        start = s.start if s.start is not None else 0
+        stop = s.stop if s.stop is not None else shape[i]
+        chunk_size = chunks[i]
+        start_idx = start // chunk_size
+        end_idx = stop // chunk_size
+        start_indices.append(start_idx)
+        end_indices.append(end_idx)
+        n_chunks.append(shape[i] // chunk_size)
+
+    # Get all chunk combinations in the slice
+    indices = [range(start, end) for start, end in zip(start_indices, end_indices, strict=False)]
+    result = []
+
+    for combination in product(*indices):
+        flat_index = 0
+        multiplier = 1
+        for idx, n in zip(reversed(range(len(n_chunks))), reversed(n_chunks), strict=False):
+            flat_index += combination[idx] * multiplier
+            multiplier *= n
+        result.append(flat_index)
+
+    # Check if chunks are consecutive if requested
+    if consecutive and result:
+        sorted_result = sorted(result)
+        if sorted_result[-1] - sorted_result[0] + 1 != len(sorted_result):
+            return []
+
+        # The array of indices must be consecutive
+        for i in range(len(sorted_result) - 1):
+            if sorted_result[i + 1] - sorted_result[i] != 1:
+                return []
+
+    return sorted(result)
+
+
 class NDOuterIterator:
     def __init__(self, ndarray: NDArray | NDField, cache_size=1):
         self.ndarray = ndarray
@@ -1836,10 +1913,45 @@ class NDArray(blosc2_ext.NDArray, Operand):
         (4, 10)
         >>> print(type(c))
         <class 'blosc2.ndarray.NDArray'>
+
+        Notes
+        -----
+        There is a fast path for slices that are aligned with underlying chunks.
+        Aligned means that the slices are made entirely with complete chunks.
         """
-        kwargs = _check_ndarray_kwargs(**kwargs)
+        if "cparams" not in kwargs:
+            kwargs["cparams"] = {
+                "codec": self.cparams.codec,
+                "clevel": self.cparams.clevel,
+                "filters": self.cparams.filters,
+            }
+        kwargs = _check_ndarray_kwargs(**kwargs)  # sets cparams to defaults
         key, mask = process_key(key, self.shape)
         start, stop, step = get_ndarray_start_stop(self.ndim, key, self.shape)
+
+        # Fast path for slices made with consecutive chunks
+        if step == (1,) * self.ndim:
+            aligned_chunks = detect_aligned_chunks(key, self.shape, self.chunks, consecutive=False)
+            if aligned_chunks:
+                # print("Aligned chunks detected", aligned_chunks)
+                # Create a new ndarray for the key slice
+                new_shape = [
+                    sp - st for sp, st in zip([k.stop for k in key], [k.start for k in key], strict=False)
+                ]
+                newarr = blosc2.empty(
+                    shape=new_shape,
+                    dtype=self.dtype,
+                    chunks=self.chunks,
+                    blocks=self.blocks,
+                    **kwargs,
+                )
+                # Get the chunks from the original array and update the new array
+                # No need for chunks to decompress and compress again
+                for order, nchunk in enumerate(aligned_chunks):
+                    chunk = self.schunk.get_chunk(nchunk)
+                    newarr.schunk.update_chunk(order, chunk)
+                return newarr
+
         key = (start, stop)
         ndslice = super().get_slice(key, mask, **kwargs)
 
@@ -3665,9 +3777,9 @@ def matmul(x1: NDArray, x2: NDArray, **kwargs: Any) -> NDArray:
 
     Parameters
     ----------
-    x1: `NDArray`
+    x1: :ref:`NDArray`
         The first input array.
-    x2: `NDArray`
+    x2: :ref:`NDArray`
         The second input array.
     kwargs: Any, optional
         Keyword arguments that are supported by the :func:`empty` constructor.
@@ -3766,6 +3878,51 @@ def matmul(x1: NDArray, x2: NDArray, **kwargs: Any) -> NDArray:
     return result.squeeze()
 
 
+def transpose(x, **kwargs: Any) -> NDArray:
+    """
+    Returns a Blosc2 NDArray with axes transposed.
+
+    Only 2D arrays are supported for now.  Other dimensions raise an error.
+
+    Parameters
+    ----------
+    x: :ref:`NDArray`
+        The input array.
+    kwargs: Any, optional
+        Keyword arguments that are supported by the :func:`empty` constructor.
+
+    Returns
+    -------
+    out: :ref:`NDArray`
+        The Blosc2 NDArray with axes transposed.
+
+    References
+    ----------
+    `numpy.transpose <https://numpy.org/doc/2.2/reference/generated/numpy.transpose.html>`_
+    """
+
+    # If arguments are dimension < 2 they are returned
+    if np.isscalar(x) or x.ndim < 2:
+        return x
+
+    # Validate arguments are dimension 2
+    if x.ndim > 2:
+        raise ValueError("Transposing arrays with dimension greater than 2 is not supported yet.")
+
+    n, m = x.shape
+    p, q = x.chunks
+    result = blosc2.zeros((m, n), dtype=np.result_type(x), **kwargs)
+
+    for row in range(0, n, p):
+        row_end = (row + p) if (row + p) < n else n
+        for col in range(0, m, q):
+            col_end = (col + q) if (col + q) < m else m
+            aux = x[row:row_end, col:col_end]
+            result[col:col_end, row:row_end] = np.transpose(aux).copy()
+
+    return result
+
+
 # Class for dealing with fields in an NDArray
 # This will allow to access fields by name in the dtype of the NDArray
 class NDField(Operand):

blosc2-3.3.0/src/blosc2/version.py

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

{blosc2-3.2.1 → blosc2-3.3.0}/tests/ndarray/test_matmul.py

@@ -21,11 +21,50 @@ import blosc2
 )
 @pytest.mark.parametrize(
     "dtype",
-    {np.float32, np.float64, np.complex64, np.complex128},
+    {np.float32, np.float64},
 )
 def test_matmul(ashape, achunks, ablocks, bshape, bchunks, bblocks, dtype):
-    a = blosc2.linspace(0, 10, dtype=dtype, shape=ashape, chunks=achunks, blocks=ablocks)
-    b = blosc2.linspace(0, 10, dtype=dtype, shape=bshape, chunks=bchunks, blocks=bblocks)
+    a = blosc2.linspace(0, 1, dtype=dtype, shape=ashape, chunks=achunks, blocks=ablocks)
+    b = blosc2.linspace(0, 1, dtype=dtype, shape=bshape, chunks=bchunks, blocks=bblocks)
+    c = blosc2.matmul(a, b)
+
+    na = a[:]
+    nb = b[:]
+    nc = np.matmul(na, nb)
+
+    np.testing.assert_allclose(c, nc, rtol=1e-6)
+
+
+@pytest.mark.parametrize(
+    ("ashape", "achunks", "ablocks"),
+    {
+        ((12, 10), (7, 5), (3, 3)),
+        ((10,), (9,), (7,)),
+    },
+)
+@pytest.mark.parametrize(
+    ("bshape", "bchunks", "bblocks"),
+    {
+        ((10,), (4,), (2,)),
+        ((10, 5), (3, 4), (1, 3)),
+        ((10, 12), (2, 4), (1, 2)),
+    },
+)
+@pytest.mark.parametrize(
+    "dtype",
+    {np.complex64, np.complex128},
+)
+def test_complex(ashape, achunks, ablocks, bshape, bchunks, bblocks, dtype):
+    real_part = blosc2.linspace(0, 1, shape=ashape, chunks=achunks, blocks=ablocks, dtype=dtype)
+    imag_part = blosc2.linspace(0, 1, shape=ashape, chunks=achunks, blocks=ablocks, dtype=dtype)
+    complex_matrix_a = real_part + 1j * imag_part
+    a = blosc2.asarray(complex_matrix_a)
+
+    real_part = blosc2.linspace(1, 2, shape=bshape, chunks=bchunks, blocks=bblocks, dtype=dtype)
+    imag_part = blosc2.linspace(1, 2, shape=bshape, chunks=bchunks, blocks=bblocks, dtype=dtype)
+    complex_matrix_b = real_part + 1j * imag_part
+    b = blosc2.asarray(complex_matrix_b)
+
     c = blosc2.matmul(a, b)
 
     na = a[:]

blosc2-3.3.0/tests/ndarray/test_slice.py

@@ -0,0 +1,93 @@
+#######################################################################
+# Copyright (c) 2019-present, Blosc Development Team <blosc@blosc.org>
+# All rights reserved.
+#
+# This source code is licensed under a BSD-style license (found in the
+# LICENSE file in the root directory of this source tree)
+#######################################################################
+
+import numpy as np
+import pytest
+
+import blosc2
+
+argnames = "shape, chunks, blocks, slices, dtype"
+argvalues = [
+    ([456], [258], [73], slice(0, 1), np.int32),
+    ([77, 134, 13], [31, 13, 5], [7, 8, 3], (slice(3, 7), slice(50, 100), 7), np.float64),
+    ([12, 13, 14, 15, 16], [5, 5, 5, 5, 5], [2, 2, 2, 2, 2], (slice(1, 3), ..., slice(3, 6)), np.float32),
+    # Consecutive slices
+    ((10, 100, 300), (5, 25, 50), (1, 5, 10), (slice(0, 10), slice(0, 100), slice(0, 300)), np.int32),
+    ((10, 100, 300), (5, 25, 50), (1, 5, 10), (slice(0, 5), slice(0, 100), slice(0, 300)), np.int32),
+    ((10, 100, 300), (5, 25, 50), (1, 5, 10), (slice(0, 5), slice(0, 25), slice(0, 200)), np.int32),
+    ((10, 100, 300), (5, 25, 50), (1, 5, 10), (slice(0, 5), slice(0, 25), slice(0, 50)), np.int32),
+    # Aligned slices
+    ((10, 100, 300), (5, 25, 50), (1, 5, 10), (slice(10, 50), slice(25, 100), slice(50, 300)), np.int32),
+    ((10, 100, 300), (5, 25, 50), (1, 5, 10), (slice(10, 40), slice(25, 75), slice(100, 200)), np.int32),
+    ((10, 100, 300), (5, 25, 50), (1, 5, 10), (slice(20, 35), slice(50, 75), slice(100, 300)), np.int32),
+    ((10, 100, 300), (5, 25, 50), (1, 5, 10), (slice(20, 25), slice(25, 50), slice(50, 100)), np.int32),
+    # Non-consecutive slices
+    ((10, 100, 300), (5, 25, 50), (1, 5, 10), (slice(0, 10), slice(0, 100), slice(0, 300 - 1)), np.int32),
+    ((10, 100, 300), (5, 25, 50), (1, 5, 10), (slice(0, 5), slice(0, 100 - 1), slice(0, 300)), np.int32),
+    ((10, 100, 300), (5, 25, 50), (1, 5, 10), (slice(0, 5 - 1), slice(0, 25), slice(0, 200)), np.int32),
+    ((10, 100, 300), (5, 25, 50), (1, 5, 10), (slice(0, 5), slice(0, 25), slice(0, 50 - 1)), np.int32),
+    # Non-aligned slices
+    ((10, 100, 300), (5, 25, 50), (1, 5, 10), (slice(10, 50 - 1), slice(25, 100), slice(50, 300)), np.int32),
+    ((10, 100, 300), (5, 25, 50), (1, 5, 10), (slice(10, 40), slice(25, 75 - 1), slice(100, 200)), np.int32),
+    ((10, 100, 300), (5, 25, 50), (1, 5, 10), (slice(20, 35), slice(50, 75), slice(100, 300 - 1)), np.int32),
+    ((10, 100, 300), (5, 25, 50), (1, 5, 10), (slice(20 + 1, 25), slice(25, 50), slice(50, 100)), np.int32),
+]
+
+
+@pytest.mark.parametrize(argnames, argvalues)
+def test_slice(shape, chunks, blocks, slices, dtype):
+    size = int(np.prod(shape))
+    nparray = np.arange(size, dtype=dtype).reshape(shape)
+    a = blosc2.asarray(nparray, chunks=chunks, blocks=blocks)
+    b = a.slice(slices)
+    np_slice = a[slices]
+    assert b.shape == np_slice.shape
+    np.testing.assert_almost_equal(b[...], np_slice)
+
+
+@pytest.mark.parametrize(argnames, argvalues)
+def test_slice_codec_and_clevel(shape, chunks, blocks, slices, dtype):
+    size = int(np.prod(shape))
+    nparray = np.arange(size, dtype=dtype).reshape(shape)
+    a = blosc2.asarray(
+        nparray,
+        chunks=chunks,
+        blocks=blocks,
+        cparams={"codec": blosc2.Codec.LZ4, "clevel": 6, "filters": [blosc2.Filter.BITSHUFFLE]},
+    )
+
+    b = a.slice(slices)
+    assert b.cparams.codec == a.cparams.codec
+    assert b.cparams.clevel == a.cparams.clevel
+    assert b.cparams.filters == a.cparams.filters
+
+
+argnames = "shape, chunks, blocks, slices, dtype, chunks2, blocks2"
+argvalues = [
+    ([456], [258], [73], slice(0, 1), np.int32, [1], [1]),
+    ([77, 134, 13], [31, 13, 5], [7, 8, 3], (slice(3, 7), slice(50, 100), 7), np.float64, [3, 50], None),
+    (
+        [12, 13, 14, 15, 16],
+        [5, 5, 5, 5, 5],
+        [2, 2, 2, 2, 2],
+        (slice(1, 3), ..., slice(3, 6)),
+        np.float32,
+        None,
+        [2, 3, 3, 5, 2],
+    ),
+]
+
+
+@pytest.mark.parametrize(argnames, argvalues)
+def test_slice_chunks_blocks(shape, chunks, blocks, chunks2, blocks2, slices, dtype):
+    size = int(np.prod(shape))
+    nparray = np.arange(size, dtype=dtype).reshape(shape)
+    a = blosc2.asarray(nparray, chunks=chunks, blocks=blocks)
+    b = a.slice(slices, chunks=chunks2, blocks=blocks2)
+    np_slice = a[slices]
+    np.testing.assert_almost_equal(b[...], np_slice)

blosc2-3.3.0/tests/ndarray/test_transpose.py

@@ -0,0 +1,104 @@
+import numpy as np
+import pytest
+
+import blosc2
+
+
+@pytest.fixture(
+    params=[
+        ((3, 3), (2, 2), (1, 1)),
+        ((12, 11), (7, 5), (6, 2)),
+        ((1, 5), (1, 4), (1, 3)),
+        ((51, 603), (22, 99), (13, 29)),
+        ((10,), (5,), None),
+        ((31,), (14,), (9,)),
+    ]
+)
+def shape_chunks_blocks(request):
+    return request.param
+
+
+@pytest.mark.parametrize(
+    "dtype",
+    {np.int32, np.int64, np.float32, np.float64},
+)
+def test_transpose(shape_chunks_blocks, dtype):
+    shape, chunks, blocks = shape_chunks_blocks
+    a = blosc2.linspace(0, 1, shape=shape, chunks=chunks, blocks=blocks, dtype=dtype)
+    at = blosc2.transpose(a)
+
+    na = a[:]
+    nat = np.transpose(na)
+
+    np.testing.assert_allclose(at, nat)
+
+
+@pytest.mark.parametrize(
+    "dtype",
+    {np.complex64, np.complex128},
+)
+def test_complex(shape_chunks_blocks, dtype):
+    shape, chunks, blocks = shape_chunks_blocks
+    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 + 1j * imag_part
+
+    a = blosc2.asarray(complex_matrix)
+    at = blosc2.transpose(a)
+
+    na = a[:]
+    nat = np.transpose(na)
+
+    np.testing.assert_allclose(at, nat)
+
+
+@pytest.mark.parametrize(
+    "scalar",
+    {
+        1,  # int
+        5.1,  # float
+        1 + 2j,  # complex
+        np.int8(2),  # NumPy int8
+        np.int16(3),  # NumPy int16
+        np.int32(4),  # NumPy int32
+        np.int64(5),  # NumPy int64
+        np.float32(5.2),  # NumPy float32
+        np.float64(5.3),  # NumPy float64
+        np.complex64(0 + 3j),  # NumPy complex64
+        np.complex128(2 - 4j),  # NumPy complex128
+    },
+)
+def test_scalars(scalar):
+    at = blosc2.transpose(scalar)
+    nat = np.transpose(scalar)
+
+    np.testing.assert_allclose(at, nat)
+
+
+@pytest.mark.parametrize(
+    "shape",
+    [
+        (3, 3, 3),
+        (12, 10, 10),
+        (10, 10, 10, 11),
+        (5, 4, 3, 2, 1, 1),
+    ],
+)
+def test_dims(shape):
+    a = blosc2.linspace(0, 1, shape=shape)
+
+    with pytest.raises(ValueError):
+        blosc2.transpose(a)
+
+
+def test_disk():
+    a = blosc2.linspace(0, 1, shape=(3, 4), urlpath="a_test.b2nd", mode="w")
+    c = blosc2.transpose(a, urlpath="c_test.b2nd", mode="w")
+
+    na = a[:]
+    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")

blosc2-3.2.1/src/blosc2/version.py

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