blosc2 3.3.1__tar.gz → 3.3.3__tar.gz

{blosc2-3.3.1 → blosc2-3.3.3}/.pre-commit-config.yaml

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

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

@@ -1,16 +1,10 @@
-Announcing Python-Blosc2 3.3.1
+Announcing Python-Blosc2 3.3.3
 ==============================
 
-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 improved the
+correct chaining of *string* lazy expressions (there is still room for
+improvement).  Also, a new version of C-Blosc2 (v2.7.2.dev) that fixes
+mmap issues on Windows is used; thanks to @JanSellner for the fix.
 
 You can think of Python-Blosc2 3.x as an extension of NumPy/numexpr that:
 

{blosc2-3.3.1 → blosc2-3.3.3}/CMakeLists.txt

@@ -50,7 +50,7 @@ else()
     include(FetchContent)
     FetchContent_Declare(blosc2
         GIT_REPOSITORY https://github.com/Blosc/c-blosc2
-        GIT_TAG 5fcd6fbf9ffcf613fabdb1eb3a90eeb12f7c04fe  # v2.17.1
+        GIT_TAG 3f9c085c0c0f357b140fb5a50d1f8df06de3383a  # v2.17.1 + mmap fix
     )
     FetchContent_MakeAvailable(blosc2)
     include_directories("${blosc2_SOURCE_DIR}/include")

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.2
 Name: blosc2
-Version: 3.3.1
+Version: 3.3.3
 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.3}/RELEASE_NOTES.md

@@ -1,5 +1,48 @@
 # Release notes
 
+## Changes from 3.3.2 to 3.3.3
+
+* Expand possibilities for chaining string-based lazy expressions to include
+  main operand types (LazyExpr and NDArray). Still have to incorporate other
+  data types (which do not have shape attribute, e.g. int, float etc.).
+  See #406.
+
+* Fix indexing for lazy expressions, and allow use of None in getitem.
+  See PR #402.
+
+* Fix incorrect appending of dim to computed reductions. See PR #404.
+
+* Fix `blosc2.linspace()` for incompatible num/shape.  See PR #408.
+
+* Add support for NumPy dtypes that are n-dimensional (e.g.
+  `np.dtype(("<i4,>f4", (10,))),`).
+
+* New MAX_DIM constant for the maximum number of dimensions supported.
+  This is useful for checking if a given array is too large to be handled.
+
+* More refinements on guessing cache sizes for Linux.
+
+* Update to C-Blosc2 2.17.2.dev.  Now, we are forcing the flush of modified
+  pages only in write mode for mmap files. This fixes mmap issues on Windows.
+  Thanks to @JanSellner for the implementation.
+
+## 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.
+
+* We are distributing Python 3.10 wheels now.
+
 ## 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.3}/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.2 released on 2025-05-01!</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.3}/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.3"
 
 
 [project.optional-dependencies]
@@ -110,7 +111,7 @@ extend-select = [
     "RET",
     "RUF",
     "SIM",
-    "TCH",
+    "TC",
     "UP",
 ]
 ignore = [

{blosc2-3.3.1 → blosc2-3.3.3}/src/blosc2/__init__.py

@@ -109,6 +109,7 @@ from .blosc2_ext import (
     GLOBAL_REGISTERED_CODECS_STOP,
     MAX_BLOCKSIZE,
     MAX_BUFFERSIZE,
+    MAX_DIM,
     MAX_OVERHEAD,
     MAX_TYPESIZE,
     MIN_HEADER_LENGTH,

{blosc2-3.3.1 → blosc2-3.3.3}/src/blosc2/blosc2_ext.pyx

@@ -542,6 +542,7 @@ MAX_TYPESIZE = BLOSC2_MAXTYPESIZE
 MAX_BUFFERSIZE = BLOSC2_MAX_BUFFERSIZE
 MAX_BLOCKSIZE = BLOSC2_MAXBLOCKSIZE
 MAX_OVERHEAD = BLOSC2_MAX_OVERHEAD
+MAX_DIM = B2ND_MAX_DIM
 VERSION_STRING = (<char*>BLOSC2_VERSION_STRING).decode("utf-8")
 VERSION_DATE = (<char*>BLOSC2_VERSION_DATE).decode("utf-8")
 MIN_HEADER_LENGTH = BLOSC_MIN_HEADER_LENGTH
@@ -2391,7 +2392,7 @@ cdef class NDArray:
         str_dtype = bytes_dtype.decode("utf-8")
         try:
             dtype = np.dtype(str_dtype)
-        except TypeError:
+        except (ValueError, TypeError):
             dtype = np.dtype(ast.literal_eval(str_dtype))
         self._dtype = dtype
         return dtype

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

@@ -1164,50 +1164,58 @@ def apple_silicon_cache_size(cache_level: int) -> int:
     return size.value
 
 
-def get_l3_cache_info():
+def get_cache_info(cache_level: int) -> tuple:
     result = subprocess.run(["lscpu", "--json"], capture_output=True, text=True)
     lscpu_info = json.loads(result.stdout)
+    if cache_level == 0:
+        cache_level = "1d"
     for entry in lscpu_info["lscpu"]:
-        if entry["field"] == "L3 cache:":
+        if entry["field"] == f"L{cache_level} cache:":
             size_str, instances_str = entry["data"].split(" (")
-            size = int(size_str.split()[0]) * 1024 * 1024  # Convert MiB to bytes
+            size, units = size_str.split()
+            size = int(size)
+            if units == "KiB":
+                size *= 2**10
+            elif units == "MiB":
+                size *= 2**20
+            elif units == "GiB":
+                size *= 2**30
+            else:
+                raise ValueError("Unrecognized unit when guessing cache units")
             instances = int(instances_str.split()[0])
             return size, instances
 
-    raise ValueError("L3 cache not found in lscpu output")
+    raise ValueError(f"L{cache_level} cache not found in lscpu output")
 
 
 def linux_cache_size(cache_level: int, default_size: int) -> int:
     """Get the data cache_level size in bytes for Linux."""
     cache_size = default_size
-    if cache_level == 3:
-        # In modern multicore CPUs, the L3 cache is normally shared among all core complexes (CCX),
-        # but sysfs only reports the cache size for each complex, so better use lscpu, if available.
-        try:
-            l3_cache_size, l3_cache_instances = get_l3_cache_info()
-            # What comes next is a heuristic to guess the most appropriate L3 cache size.
-            # Essentially, this is the result of different experiments, mainly on AMD CPUs
-            # (in particular, Ryzen 9800X3D with 8 cores, and EPYC 9454P with 48 cores).
-            # For Intel, YMMV, but my guess is that they are not using the same CCX approach.
-            l3_cache_size *= l3_cache_instances
-            if l3_cache_instances > 1:
-                # This is yet another heuristic for large CPUs with core sets (CCX) having
-                # their own L3.  No idea why, but it seems to work well.
-                l3_cache_size *= l3_cache_instances // 2
-            return l3_cache_size
-        except (FileNotFoundError, ValueError):
-            # If lscpu is not available or the cache size cannot be read, try with sysfs
-            pass
     try:
+        # Try to read the cache size from sysfs
         with open(f"/sys/devices/system/cpu/cpu0/cache/index{cache_level}/size") as f:
             size = f.read()
             if size.endswith("K\n"):
-                cache_size = int(size[:-2]) * 1024
+                cache_size = int(size[:-2]) * 2**10
             elif size.endswith("M\n"):
-                cache_size = int(size[:-2]) * 1024 * 1024
+                cache_size = int(size[:-2]) * 2**20
+            elif size.endswith("G\n"):
+                cache_size = int(size[:-2]) * 2**30
     except FileNotFoundError:
-        # If the cache size cannot be read, return the default size
-        pass
+        # Try with lscpu, if available.
+        try:
+            cache_size, cache_instances = get_cache_info(cache_level)
+            # cache_instances typically refers to the number of sockets, CCXs or cores,
+            # depending on the CPU and cache level.
+            # In general, dividing the cache size by the number of instances would bring
+            # best performance for private caches (L1 and L2).  For shared caches (L3),
+            # this should be the case as well, but more experimentation is needed.
+            cache_size //= cache_instances
+            return cache_size
+        except (FileNotFoundError, ValueError):
+            # If lscpu is not available or the cache size cannot be read from sysfs,
+            # return the default size.
+            pass
     return cache_size
 
 
@@ -1322,9 +1330,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 +1537,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 +1570,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.3}/src/blosc2/lazyexpr.py

@@ -37,7 +37,7 @@ import numpy as np
 import blosc2
 from blosc2 import compute_chunks_blocks
 from blosc2.info import InfoReporter
-from blosc2.ndarray import _check_allowed_dtypes, get_chunks_idx, is_inside_new_expr
+from blosc2.ndarray import _check_allowed_dtypes, get_chunks_idx, is_inside_new_expr, process_key
 
 if not blosc2.IS_WASM:
     import numexpr
@@ -630,6 +630,107 @@ def get_expr_operands(expression: str) -> set:
     return set(visitor.operands)
 
 
+def conserve_functions(  # noqa: C901
+    expression: str,
+    operands_old: dict[str, blosc2.NDArray | blosc2.LazyExpr],
+    operands_new: dict[str, blosc2.NDArray | blosc2.LazyExpr],
+) -> tuple(str, dict[str, blosc2.NDArray]):
+    """
+    Given an expression in string form, return its operands.
+
+    Parameters
+    ----------
+    expression : str
+        The expression in string form.
+
+    operands_old: dict[str : blosc2.ndarray | blosc2.LazyExpr]
+        Dict of operands from expression prior to eval.
+
+    operands_new: dict[str : blosc2.ndarray | blosc2.LazyExpr]
+        Dict of operands from expression after eval.
+    Returns
+    -------
+    newexpression
+        A modified string expression with the functions/constructors conserved and
+        true operands rebased and written in o- notation.
+    newoperands
+        Dict of the set of rebased operands.
+    """
+
+    operand_to_key = {id(v): k for k, v in operands_new.items()}
+    for k, v in operands_old.items():  # extend operands_to_key with old operands
+        if isinstance(
+            v, blosc2.LazyExpr
+        ):  # unroll operands in LazyExpr (only necessary when have reduced a lazyexpr)
+            d = v.operands
+        else:
+            d = {k: v}
+        for newk, newv in d.items():
+            try:
+                operand_to_key[id(newv)]
+            except KeyError:
+                newk = (
+                    f"o{len(operands_new)}" if newk in operands_new else newk
+                )  # possible that names coincide
+                operand_to_key[id(newv)] = newk
+                operands_new[newk] = newv
+
+    class OperandVisitor(ast.NodeVisitor):
+        def __init__(self):
+            self.operandmap = {}
+            self.operands = {}
+            self.opcounter = 0
+            self.function_names = set()
+
+        def update_func(self, localop):
+            k = operand_to_key[id(localop)]
+            if k not in self.operandmap:
+                newkey = f"o{self.opcounter}"
+                self.operands[newkey] = operands_new[k]
+                self.operandmap[k] = newkey
+                self.opcounter += 1
+                return newkey
+            else:
+                return self.operandmap[k]
+
+        def visit_Name(self, node):
+            if node.id == "np":  # Skip NumPy namespace (e.g. np.int8, which will be treated separately)
+                return
+            if node.id in self.function_names:  # Skip function names
+                return
+            elif node.id not in dtype_symbols:
+                localop = operands_old[node.id]
+                if isinstance(localop, blosc2.LazyExpr):
+                    newexpr = localop.expression
+                    for (
+                        opname,
+                        v,
+                    ) in localop.operands.items():  # expression operands already in terms of basic operands
+                        newopname = self.update_func(v)
+                        newexpr = re.sub(
+                            rf"(?<=\s){opname}|(?<=\(){opname}", newopname, newexpr
+                        )  # replace with newopname
+                    node.id = newexpr
+                else:
+                    node.id = self.update_func(localop)
+            else:
+                pass
+            self.generic_visit(node)
+
+        def visit_Call(self, node):
+            if isinstance(
+                node.func, ast.Name
+            ):  # visits Call first, then Name, so don't increment operandcounter yet
+                self.function_names.add(node.func.id)
+            self.generic_visit(node)
+
+    tree = ast.parse(expression)
+    visitor = OperandVisitor()
+    visitor.visit(tree)
+    newexpression, newoperands = ast.unparse(tree), visitor.operands
+    return newexpression, newoperands
+
+
 class TransformNumpyCalls(ast.NodeTransformer):
     def __init__(self):
         self.replacements = {}
@@ -1481,7 +1582,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 +2021,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}
@@ -2434,22 +2535,24 @@ class LazyExpr(LazyArray):
             _globals = get_expr_globals(self.expression)
             lazy_expr = eval(self.expression, _globals, self.operands)
             if not isinstance(lazy_expr, blosc2.LazyExpr):
+                key, _ = process_key(item, self.shape)
                 # An immediate evaluation happened (e.g. all operands are numpy arrays)
                 if hasattr(self, "_where_args"):
                     # We need to apply the where() operation
                     if len(self._where_args) == 1:
                         # We have a single argument
                         where_x = self._where_args["_where_x"]
-                        return where_x[:][lazy_expr]
+                        return (where_x[:][lazy_expr])[key]
                     if len(self._where_args) == 2:
                         # We have two arguments
                         where_x = self._where_args["_where_x"]
                         where_y = self._where_args["_where_y"]
-                        return np.where(lazy_expr, where_x, where_y)
+                        return np.where(lazy_expr, where_x, where_y)[key]
                 if hasattr(self, "_output"):
                     # This is not exactly optimized, but it works for now
-                    self._output[:] = lazy_expr
-                return lazy_expr
+                    self._output[:] = lazy_expr[key]
+                    return self._output
+                return lazy_expr[key]
 
             return chunked_eval(lazy_expr.expression, lazy_expr.operands, item, **kwargs)
 
@@ -2676,10 +2779,14 @@ class LazyExpr(LazyArray):
             _dtype = new_expr.dtype
             _shape = new_expr.shape
             if isinstance(new_expr, blosc2.LazyExpr):
-                # Restore the original expression and operands
-                new_expr.expression = _expression
+                # DO NOT restore the original expression and operands
+                # Instead rebase operands and restore only constructors
+                expression_, operands_ = conserve_functions(
+                    _expression, _operands, new_expr.operands | local_vars
+                )
+                new_expr.expression = f"({expression_})"  # force parenthesis
                 new_expr.expression_tosave = expression
-                new_expr.operands = _operands
+                new_expr.operands = operands_
                 new_expr.operands_tosave = operands
             else:
                 # An immediate evaluation happened (e.g. all operands are numpy arrays)

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

@@ -2914,6 +2914,8 @@ def _check_shape(shape):
         shape = (shape,)
     elif not isinstance(shape, tuple | list):
         raise TypeError("shape should be a tuple or a list!")
+    if len(shape) > blosc2.MAX_DIM:
+        raise ValueError(f"shape length {len(shape)} is too large (>{blosc2.MAX_DIM})!")
     return shape
 
 
@@ -3266,7 +3268,9 @@ def arange(
 
 
 # Define a numpy linspace-like function
-def linspace(start, stop, num=50, endpoint=True, dtype=np.float64, shape=None, c_order=True, **kwargs: Any):
+def linspace(
+    start, stop, num=None, endpoint=True, dtype=np.float64, shape=None, c_order=True, **kwargs: Any
+):
     """Return evenly spaced numbers over a specified interval.
 
     This is similar to `numpy.linspace` but it returns a `NDArray`
@@ -3308,8 +3312,17 @@ def linspace(start, stop, num=50, endpoint=True, dtype=np.float64, shape=None, c
         stop_ = start_ + lout / num * (stop - start)
         output[:] = np.linspace(start_, stop_, lout, endpoint=False, dtype=output.dtype)
 
-    if not shape:
-        shape = (num,)
+    if shape is None or num is None:
+        if shape is None and num is None:
+            raise ValueError("Either `shape` or `num` must be specified.")
+        if shape is None:  # num is not None
+            shape = (num,)
+        else:  # num is none
+            num = math.prod(shape)
+
+    # check compatibility of shape and num
+    if math.prod(shape) != num:
+        raise ValueError("The specified shape is not consistent with the specified num value")
     dtype = _check_dtype(dtype)
 
     if is_inside_new_expr():
@@ -3624,17 +3637,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 +3889,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 +3964,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 +3974,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 +4040,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.3/src/blosc2/version.py

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

{blosc2-3.3.1 → blosc2-3.3.3}/tests/ndarray/test_evaluate.py

@@ -27,7 +27,7 @@ def sample_data(request):
     # The jit decorator can work with any numpy or NDArray params in functions
     a = blosc2.linspace(0, 1, shape[0] * shape[1], dtype=dtype, shape=shape)
     b = np.linspace(1, 2, shape[0] * shape[1], dtype=dtype).reshape(shape)
-    c = blosc2.linspace(-10, 10, cshape[0], dtype=dtype, shape=cshape)
+    c = blosc2.linspace(-10, 10, np.prod(cshape), dtype=dtype, shape=cshape)
     return a, b, c, shape
 
 

{blosc2-3.3.1 → blosc2-3.3.3}/tests/ndarray/test_jit.py

@@ -26,7 +26,7 @@ def sample_data(request):
     # The jit decorator can work with any numpy or NDArray params in functions
     a = blosc2.linspace(0, 1, shape[0] * shape[1], dtype=dtype, shape=shape)
     b = np.linspace(1, 2, shape[0] * shape[1], dtype=dtype).reshape(shape)
-    c = blosc2.linspace(-10, 10, cshape[0], dtype=dtype, shape=cshape)
+    c = blosc2.linspace(-10, 10, np.prod(cshape), dtype=dtype, shape=cshape)
     return a, b, c, shape