blosc2 3.3.2__tar.gz → 3.3.3__tar.gz

{blosc2-3.3.2 → 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.2 → blosc2-3.3.3}/ANNOUNCE.rst

@@ -1,11 +1,10 @@
-Announcing Python-Blosc2 3.3.2
+Announcing Python-Blosc2 3.3.3
 ==============================
 
-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 (``&``, ``|``, ``^``...).
+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.2 → 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.2 → blosc2-3.3.3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.2
 Name: blosc2
-Version: 3.3.2
+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>

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

@@ -1,5 +1,31 @@
 # 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.
@@ -15,6 +41,8 @@
 * 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.2 → 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.1 released on 2025-04-20!</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.2 → blosc2-3.3.3}/pyproject.toml

@@ -41,7 +41,7 @@ dependencies = [
     "py-cpuinfo; platform_machine != 'wasm32'",
     "requests",
 ]
-version = "3.3.2"
+version = "3.3.3"
 
 
 [project.optional-dependencies]
@@ -111,7 +111,7 @@ extend-select = [
     "RET",
     "RUF",
     "SIM",
-    "TCH",
+    "TC",
     "UP",
 ]
 ignore = [

{blosc2-3.3.2 → 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.2 → 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.2 → 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
 
 

{blosc2-3.3.2 → 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 = {}
@@ -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 = f"({_expression})"  # forcibly add parenthesis
-                new_expr.expression_tosave = _expression
-                new_expr.operands = _operands
+                # 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_tosave = operands
             else:
                 # An immediate evaluation happened (e.g. all operands are numpy arrays)

{blosc2-3.3.2 → 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():

blosc2-3.3.3/src/blosc2/version.py

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

{blosc2-3.3.2 → 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.2 → 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
 
 

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

@@ -1354,45 +1354,52 @@ def test_chain_expressions():
     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())
-#
+    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: Eventually this test should pass
+    # expr1 = blosc2.lazyexpr("arange(N) + b")
+    # expr2 = blosc2.lazyexpr("a * b + 1")
+    # expr = blosc2.lazyexpr("expr1 - expr2")
+    # expr_final = blosc2.lazyexpr("expr * expr")
+    # nres = (expr * expr)[:]
+    # res = expr_final.compute()
+    # np.testing.assert_allclose(res[:], nres)
+
+
+# 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")
+    assert (myle4[:] == le4[:]).all()

{blosc2-3.3.2 → blosc2-3.3.3}/tests/ndarray/test_ndarray.py

@@ -187,6 +187,14 @@ def test_linspace(ss, shape, dtype, chunks, blocks, endpoint, c_order):
     else:
         # This is chunk order, so testing is more laborious, and not really necessary
         pass
+    with pytest.raises(ValueError):
+        a = blosc2.linspace(start, stop, 10, shape=(20,))  # num incompatible with shape
+    with pytest.raises(ValueError):
+        a = blosc2.linspace(start, stop)  # num or shape should be specified
+    a = blosc2.linspace(start, stop, shape=(20,))  # should have length 20
+    assert a.shape == (20,)
+    a = blosc2.linspace(start, stop, num=20)  # should have length 20
+    assert a.shape == (20,)
 
 
 @pytest.mark.parametrize(("N", "M"), [(10, None), (10, 20), (20, 10)])

{blosc2-3.3.2 → blosc2-3.3.3}/tests/ndarray/test_reductions.py

@@ -418,3 +418,13 @@ def test_save_constructor_reduce2(shape, disk, compute):
         blosc2.remove_urlpath(urlpath_a)
         blosc2.remove_urlpath(urlpath_b)
         blosc2.remove_urlpath("out.b2nd")
+
+
+def test_reduction_index():
+    shape = (20, 20)
+    a = blosc2.linspace(0, 20, num=np.prod(shape), shape=shape)
+    arr = blosc2.lazyexpr("sum(a,axis=0)", {"a": a})
+    newarr = arr.compute()
+    assert arr[:10].shape == (10,)
+    assert arr[0].shape == (1,)
+    assert arr.shape == newarr.shape

{blosc2-3.3.2 → blosc2-3.3.3}/tests/ndarray/test_zeros.py

@@ -135,3 +135,40 @@ def test_large_typesize(shape, typesize, asarray):
     else:
         b = blosc2.zeros(shape, dtype=dtype)
     assert np.array_equal(b[0], a[0])
+
+
+@pytest.mark.parametrize(
+    "dtype",
+    [
+        np.dtype(("<f8", (10,))),
+        np.dtype(("<i8", (10,))),
+        np.dtype(("<i4,>f4", (10,))),
+    ],
+)
+def test_nd_dtype(dtype):
+    # Test that the dtype is correctly set for a 1D array with a nested dtype
+    a = blosc2.zeros((1,), dtype=dtype)
+    assert a.dtype == dtype
+    b = np.zeros((1,), dtype=dtype)
+    if dtype.base.fields:  # ("<i8,>f4", (10,))
+        # Check values by converting to a dtype without a structure
+        a2 = a[:].view(dtype=np.int8)
+        b2 = b[:].view(dtype=np.int8)
+        np.testing.assert_equal(a2, b2)
+    else:
+        np.testing.assert_equal(a[:], b)
+
+
+def test_shape_empty():
+    # Test that the shape is correctly set to () for an empty array
+    a = blosc2.zeros((), dtype=np.int32)
+    assert a.shape == ()
+    assert a.dtype == np.int32
+    b = np.zeros((), dtype=np.int32)
+    np.testing.assert_equal(a[()], b)
+
+
+def test_shape_max_dims():
+    # Test that the shape cannot exceed the maximum number of dimensions
+    with pytest.raises(ValueError):
+        a = blosc2.zeros((1,) * (blosc2.MAX_DIM + 1), dtype=np.int32)

blosc2-3.3.2/src/blosc2/version.py

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