blosc2 3.3.3__tar.gz → 3.3.4__tar.gz

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

@@ -1,10 +1,11 @@
-Announcing Python-Blosc2 3.3.3
+Announcing Python-Blosc2 3.3.4
 ==============================
 
-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.
+This is a bugfix release, with some minor optimizations. We further improved the
+correct chaining of *string* lazy expressions (to allow operands with more
+diverse data types). In addition, both indexing and where expressions are now
+supported within *string* lazy expressions. Finally, casting rules have
+been improved to be more consistent with NumPy.
 
 You can think of Python-Blosc2 3.x as an extension of NumPy/numexpr that:
 

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

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

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

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

@@ -1,5 +1,23 @@
 # Release notes
 
+## Changes from 3.3.4 to 3.3.5
+
+XXX version-specific blurb XXX
+
+## Changes from 3.3.3 to 3.3.4
+
+* Expand possibilities for chaining string-based lazy expressions to incorporate
+  data types which do not have shape attribute, e.g. int, float etc.
+  See #406 and PR #411.
+
+* Enable slicing within string-based lazy expressions. See PR #414.
+
+* Improved casting for string-based lazy expressions.
+
+* Documentation improvements, see PR #410.
+
+* Compatibility fixes for working with `h5py` files.
+
 ## Changes from 3.3.2 to 3.3.3
 
 * Expand possibilities for chaining string-based lazy expressions to include

{blosc2-3.3.3 → blosc2-3.3.4}/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.2 released on 2025-05-01!</a>
+           style="font-size: 1.5em;">Version 3.3.3 released on 2025-05-14!</a>
         <span style="display: inline-block; width: 20px;"></span>
         <span style="font-family: monospace;">pip install blosc2 -U</span>
     </p>

{blosc2-3.3.3 → blosc2-3.3.4}/doc/reference/classes.rst

@@ -12,3 +12,4 @@ Main Classes
     proxy
     proxysource
     proxyndsource
+    simpleproxy

{blosc2-3.3.3 → blosc2-3.3.4}/doc/reference/proxysource.rst

@@ -4,8 +4,8 @@ ProxySource
 ===========
 
 Base interface for all supported sources in :ref:`Proxy` and are not NDim objects.
-For example, a file, a memory buffer, a network resource, etc.  For NDims, see
-:ref:`ProxyNDSource`.
+For example, a file, a memory buffer, a network resource, etc.  For n-dimemsional
+ones, see :ref:`ProxyNDSource`.
 
 .. currentmodule:: blosc2.ProxySource
 

blosc2-3.3.4/doc/reference/simpleproxy.rst

@@ -0,0 +1,30 @@
+.. _SimpleProxy:
+
+SimpleProxy
+===========
+
+Simple proxy for a NumPy array (or similar) that can be used with the Blosc2 compute engine.
+
+This only supports the __getitem__ method. No caching is performed.
+
+.. currentmodule:: blosc2.SimpleProxy
+
+Methods
+-------
+
+.. autosummary::
+    :toctree: autofiles/simpleproxy
+    :nosignatures:
+
+    __init__
+    __getitem__
+
+Attributes
+----------
+
+.. autosummary::
+    :toctree: autofiles/simpleproxy
+
+    shape
+    dtype
+    src

{blosc2-3.3.3 → blosc2-3.3.4}/doc/reference/storage.rst

@@ -1,3 +1,5 @@
+.. _CompStorParams:
+
 Compression, decompression and storage parameters
 =================================================
 

{blosc2-3.3.3 → blosc2-3.3.4}/examples/ndarray/jit-numpy-funcs.py

@@ -18,7 +18,7 @@ import blosc2
 # Create some sample data
 a = blosc2.linspace(0, 1, 10 * 100, dtype="float32", shape=(10, 100))
 b = blosc2.linspace(1, 2, 10 * 100, dtype="float32", shape=(10, 100))
-c = blosc2.linspace(-10, 10, 10, dtype="float32", shape=(100,))
+c = blosc2.linspace(-10, 10, 100, dtype="float32", shape=(100,))
 
 
 # Example 1: Basic usage of the jit decorator with reduction

{blosc2-3.3.3 → blosc2-3.3.4}/pyproject.toml

@@ -41,7 +41,7 @@ dependencies = [
     "py-cpuinfo; platform_machine != 'wasm32'",
     "requests",
 ]
-version = "3.3.3"
+version = "3.3.4"
 
 
 [project.optional-dependencies]

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

@@ -2595,8 +2595,33 @@ cdef class NDArray:
 
 
 cdef b2nd_context_t* create_b2nd_context(shape, chunks, blocks, dtype, kwargs):
-    # This is used only in constructors, dtype will always have NumPy format
-    dtype = np.dtype(dtype)
+    if isinstance(dtype, list) and len(dtype) > 0 and isinstance(dtype[0], tuple):
+        # Extract just the field names and basic dtype info
+        fields = []
+        for field in dtype:
+            name = field[0]
+            field_dtype = field[1]
+
+            # Handle different field formats:
+            # 1. ('name', ('|S10', {'h5py_encoding': 'ascii'})) - h5py style
+            # 2. ('name', '<i4') - standard NumPy style
+            # 3. ('name', '<i4', (shape,)) - NumPy with shape info
+
+            if isinstance(field_dtype, tuple) and len(field_dtype) > 0:
+                # h5py nested representation with metadata dict
+                field_dtype = field_dtype[0]
+
+            # Check if we have shape information as third element
+            if len(field) > 2 and field[2] is not None:
+                # Include the shape information
+                fields.append((name, field_dtype, field[2]))
+            else:
+                fields.append((name, field_dtype))
+
+        dtype = np.dtype(fields)
+    else:
+        dtype = np.dtype(dtype)
+
     typesize = dtype.itemsize
     if 'cparams' in kwargs:
         kwargs['cparams']['typesize'] = typesize

{blosc2-3.3.3 → blosc2-3.3.4}/src/blosc2/lazyexpr.py

@@ -116,7 +116,7 @@ dtype_symbols = {
 constructors = ("arange", "linspace", "fromiter", "zeros", "ones", "empty", "full", "frombuffer")
 # Note that, as reshape is accepted as a method too, it should always come last in the list
 constructors += ("reshape",)
-reducers = ("sum", "prod", "min", "max", "std", "mean", "var", "any", "all")
+reducers = ("sum", "prod", "min", "max", "std", "mean", "var", "any", "all", "slice")
 
 functions = [
     "sin",
@@ -541,7 +541,7 @@ def compute_smaller_slice(larger_shape, smaller_shape, larger_slice):
 
 # Define the patterns for validation
 validation_patterns = [
-    r"[\;\[\:]",  # Flow control characters
+    r"[\;]",  # Flow control characters
     r"(^|[^\w])__[\w]+__($|[^\w])",  # Dunder methods
     r"\.\b(?!real|imag|(\d*[eE]?[+-]?\d+)|(\d*[eE]?[+-]?\d+j)|\d*j\b|(sum|prod|min|max|std|mean|var|any|all|where)"
     r"\s*\([^)]*\)|[a-zA-Z_]\w*\s*\([^)]*\))",  # Attribute patterns
@@ -551,7 +551,20 @@ validation_patterns = [
 _blacklist_re = re.compile("|".join(validation_patterns))
 
 # Define valid method names
-valid_methods = {"sum", "prod", "min", "max", "std", "mean", "var", "any", "all", "where", "reshape"}
+valid_methods = {
+    "sum",
+    "prod",
+    "min",
+    "max",
+    "std",
+    "mean",
+    "var",
+    "any",
+    "all",
+    "where",
+    "reshape",
+    "slice",
+}
 valid_methods |= {"int8", "int16", "int32", "int64", "uint8", "uint16", "uint32", "uint64"}
 valid_methods |= {"float32", "float64", "complex64", "complex128"}
 valid_methods |= {"bool", "str", "bytes"}
@@ -579,7 +592,7 @@ def validate_expr(expr: str) -> None:
         raise ValueError(f"'{expr}' is not a valid expression.")
 
     # Check for invalid characters not covered by the tokenizer
-    invalid_chars = re.compile(r"[^\w\s+\-*/%().,=<>!&|~^]")
+    invalid_chars = re.compile(r"[^\w\s+\-*/%()[].,=<>!&|~^]")
     if invalid_chars.search(skip_quotes) is not None:
         invalid_chars = invalid_chars.findall(skip_quotes)
         raise ValueError(f"Expression {expr} contains invalid characters: {invalid_chars}")
@@ -706,11 +719,13 @@ def conserve_functions(  # noqa: C901
                         opname,
                         v,
                     ) in localop.operands.items():  # expression operands already in terms of basic operands
-                        newopname = self.update_func(v)
+                        # add illegal character ; to track changed operands and not overwrite later
+                        newopname = ";" + self.update_func(v)
                         newexpr = re.sub(
                             rf"(?<=\s){opname}|(?<=\(){opname}", newopname, newexpr
                         )  # replace with newopname
-                    node.id = newexpr
+                    # remove all instances of ; as all changes completed
+                    node.id = newexpr.replace(";", "")
                 else:
                     node.id = self.update_func(localop)
             else:
@@ -731,6 +746,41 @@ def conserve_functions(  # noqa: C901
     return newexpression, newoperands
 
 
+def convert_to_slice(expression):
+    """
+    Takes expression and converts all instances of [] to .slice(....)
+
+    Parameters
+    ----------
+    expression: str
+
+    Returns
+    -------
+    new_expr : str
+    """
+
+    new_expr = ""
+    skip_to_char = 0
+    for i, expr_i in enumerate(expression):
+        if i < skip_to_char:
+            continue
+        if expr_i == "[":
+            k = expression[i:].find("]")  # start checking from after [
+            slice_convert = expression[i : i + k + 1]  # include [ and ]
+            slicer = eval(f"np.s_{slice_convert}")
+            slicer = (slicer,) if not isinstance(slicer, tuple) else slicer  # standardise to tuple
+            if any(isinstance(el, str) for el in slicer):  # handle fields
+                raise ValueError("Cannot handle fields for slicing lazy expressions.")
+            slicer = str(slicer)
+            # use slice so that lazyexpr uses blosc arrays internally
+            # (and doesn't decompress according to getitem syntax)
+            new_expr += ".slice(" + slicer + ")"
+            skip_to_char = i + k + 1
+        else:
+            new_expr += expr_i
+    return new_expr
+
+
 class TransformNumpyCalls(ast.NodeTransformer):
     def __init__(self):
         self.replacements = {}
@@ -1903,9 +1953,18 @@ def infer_dtype(op, value1, value2):
         if op != "~" and value2.dtype != np.bool_:
             raise ValueError(f"Invalid operand type for {op}: {value2.dtype}")
         return np.dtype(np.bool_)
-    dtype1 = value1.dtype if hasattr(value1, "dtype") else np.array(value1).dtype
-    dtype2 = value2.dtype if hasattr(value2, "dtype") else np.array(value2).dtype
-    return np.result_type(dtype1, dtype2)
+
+    # Follow NumPy rules for scalar-array operations
+    # Create small arrays with the same dtypes and let NumPy's type promotion determine the result type
+    if np.isscalar(value1) and hasattr(value2, "shape"):
+        arr2 = np.array([0], dtype=value2.dtype)
+        return (value1 + arr2).dtype
+    elif np.isscalar(value2) and hasattr(value1, "shape"):
+        arr1 = np.array([0], dtype=value1.dtype)
+        return (arr1 + value2).dtype
+    else:
+        # Both are arrays or both are scalars, use NumPy's type promotion rules
+        return np.result_type(value1, value2)
 
 
 class LazyExpr(LazyArray):
@@ -2091,6 +2150,8 @@ class LazyExpr(LazyArray):
 
         operands = {
             key: np.ones(np.ones(len(value.shape), dtype=int), dtype=value.dtype)
+            if hasattr(value, "shape")
+            else value
             for key, value in self.operands.items()
         }
 
@@ -2532,6 +2593,7 @@ class LazyExpr(LazyArray):
     def _compute_expr(self, item, kwargs):  # noqa: C901
         if any(method in self.expression for method in reducers):
             # We have reductions in the expression (probably coming from a string lazyexpr)
+            # Also includes slice
             _globals = get_expr_globals(self.expression)
             lazy_expr = eval(self.expression, _globals, self.operands)
             if not isinstance(lazy_expr, blosc2.LazyExpr):
@@ -2764,6 +2826,7 @@ class LazyExpr(LazyArray):
     def _new_expr(cls, expression, operands, guess, out=None, where=None, ne_args=None):
         # Validate the expression
         validate_expr(expression)
+        expression = convert_to_slice(expression)
         if guess:
             # The expression has been validated, so we can evaluate it
             # in guessing mode to avoid computing reductions
@@ -2784,6 +2847,20 @@ class LazyExpr(LazyArray):
                 expression_, operands_ = conserve_functions(
                     _expression, _operands, new_expr.operands | local_vars
                 )
+                # if new_expr has where_args, must have come from where(...) - or possibly where(where(..
+                # since 5*where, where + ...  are evaluated eagerly
+                if hasattr(new_expr, "_where_args"):
+                    st = expression_.find("where(") + len(
+                        "where("
+                    )  # expr always begins where( - should have st = 6 always
+                    finalexpr = ""
+                    counter = 0
+                    for char in expression_[st:]:  # get rid of external where(...)
+                        finalexpr += char
+                        counter += 1 * (char == "(") - 1 * (char == ")")
+                        if counter == 0 and char == ",":
+                            break
+                    expression_ = finalexpr[:-1]  # remove trailing comma
                 new_expr.expression = f"({expression_})"  # force parenthesis
                 new_expr.expression_tosave = expression
                 new_expr.operands = operands_

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

@@ -1175,10 +1175,11 @@ class NDArray(blosc2_ext.NDArray, Operand):
         """The decompression parameters used by the array."""
         return self.schunk.dparams
 
-    @property
-    def storage(self) -> blosc2.Storage:
-        """The storage of the array."""
-        return self.schunk.storage
+    # TODO: Uncomment when blosc2.Storage is available
+    # @property
+    # def storage(self) -> blosc2.Storage:
+    #     """The storage of the array."""
+    #     return self.schunk.storage
 
     @property
     def urlpath(self) -> str:

{blosc2-3.3.3 → blosc2-3.3.4}/src/blosc2/proxy.py

@@ -555,18 +555,33 @@ class SimpleProxy(blosc2.Operand):
         if not hasattr(src, "shape") or not hasattr(src, "dtype"):
             # If the source is not a NumPy array, convert it to one
             src = np.asarray(src)
-        self.src = src
-        self.dtype = src.dtype
-        self.shape = src.shape
+        self._src = src
+        self._dtype = src.dtype
+        self._shape = src.shape
         # Compute reasonable values for chunks and blocks
         cparams = blosc2.CParams(clevel=0)
         self.chunks, self.blocks = blosc2.compute_chunks_blocks(
             self.shape, chunks, blocks, self.dtype, **{"cparams": cparams}
         )
 
+    @property
+    def src(self):
+        """The source object that this proxy wraps."""
+        return self._src
+
+    @property
+    def shape(self):
+        """The shape of the source array."""
+        return self._shape
+
+    @property
+    def dtype(self):
+        """The data type of the source array."""
+        return self._dtype
+
     def __getitem__(self, item: slice | list[slice]) -> np.ndarray:
         """
-        Get a slice as a numpy.ndarray using the :ref:`ProxyNumPy`.
+        Get a slice as a numpy.ndarray (via this proxy).
 
         Parameters
         ----------
@@ -577,7 +592,7 @@ class SimpleProxy(blosc2.Operand):
         out: numpy.ndarray
             An array with the data slice.
         """
-        return self.src[item]
+        return self._src[item]
 
 
 def jit(func=None, *, out=None, **kwargs):  # noqa: C901

{blosc2-3.3.3 → blosc2-3.3.4}/src/blosc2/schunk.py

@@ -1441,13 +1441,22 @@ def open(
         The path where the :ref:`SChunk` (or :ref:`NDArray`)
         is stored. If it is a remote array, a :ref:`URLPath` must be passed.
     mode: str, optional
-        The open mode.
+        Persistence mode: 'r' means read only (must exist);
+        'a' means read/write (create if it doesn't exist);
+        'w' means create (overwrite if it exists). Default is 'a'.
     offset: int, optional
         An offset in the file where super-chunk or array data is located
         (e.g. in a file containing several such objects).
     kwargs: dict, optional
-        mmap_mode: The memory mapping mode.
-        initial_mapping_size: The initial size of the memory mapping.
+        mmap_mode: str, optional
+            If set, the file will be memory-mapped instead of using the default
+            I/O functions and the `mode` argument will be ignored.
+            For more info, see :class:`blosc2.Storage`. Please note that the `w+` mode, which
+            can be used to create new files, is not supported here since only existing files
+            can be opened. You can use :func:`SChunk.__init__ <blosc2.schunk.SChunk.__init__>`
+            to create new files.
+        initial_mapping_size: int, optional
+            The initial size of the memory mapping. For more info, see :class:`blosc2.Storage`.
         cparams: dict
             A dictionary with the compression parameters, which are the same that can be
             used in the :func:`~blosc2.compress2` function.

blosc2-3.3.4/src/blosc2/version.py

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

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

@@ -1364,14 +1364,13 @@ def test_chain_expressions():
     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)
+    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
@@ -1403,3 +1402,24 @@ def test_chain_persistentexpressions():
     le4_.save("expr4.b2nd", mode="w")
     myle4 = blosc2.open("expr4.b2nd")
     assert (myle4[:] == le4[:]).all()
+
+
+@pytest.mark.parametrize(
+    "values",
+    [
+        (np.ones(10, dtype=np.uint16), 2),
+        (np.ones(10, dtype=np.uint16), np.uint32(2)),
+        (2, np.ones(10, dtype=np.uint16)),
+        (np.uint32(2), np.ones(10, dtype=np.uint16)),
+        (np.ones(10, dtype=np.uint16), 2.0),
+        (np.ones(10, dtype=np.float32), 2.0),
+        (np.ones(10, dtype=np.float32), 2.0j),
+    ],
+)
+def test_scalar_dtypes(values):
+    value1, value2 = values
+    dtype1 = (value1 + value2).dtype
+    avalue1 = blosc2.asarray(value1) if hasattr(value1, "shape") else value1
+    avalue2 = blosc2.asarray(value2) if hasattr(value2, "shape") else value2
+    dtype2 = (avalue1 * avalue2).dtype
+    assert dtype1 == dtype2, f"Expected {dtype1} but got {dtype2}"

{blosc2-3.3.3 → blosc2-3.3.4}/tests/ndarray/test_lazyexpr_fields.py

@@ -226,6 +226,47 @@ def test_where(array_fixture):
     np.testing.assert_allclose(res, nres[sl])
 
 
+# Test expressions with where() and string comps
+def test_lazy_where(array_fixture):
+    sa1, sa2, nsa1, nsa2, a1, a2, a3, a4, na1, na2, na3, na4 = array_fixture
+
+    # Test 1: where
+    # Test with string expression
+    expr = blosc2.lazyexpr("where((a1 ** 2 + a2 ** 2) > (2 * a1 * a2 + 1), 0, a1)")
+    # Test with eval
+    res = expr.compute()
+    nres = ne_evaluate("where(na1**2 + na2**2 > 2 * na1 * na2 + 1, 0, na1)")
+    np.testing.assert_allclose(res[:], nres)
+    # Test with getitem
+    sl = slice(100)
+    res = expr[sl]
+    np.testing.assert_allclose(res, nres[sl])
+
+    # Test 2: sum of wheres
+    # Test with string expression
+    expr = blosc2.lazyexpr("where(a1 < 0, 10, a1) + where(a2 < 0, 3, a2)")
+    # Test with eval
+    res = expr.compute()
+    nres = ne_evaluate("where(na1 < 0, 10, na1) + where(na2 < 0, 3, na2)")
+    np.testing.assert_allclose(res[:], nres)
+
+    # Test 3: nested wheres
+    # Test with string expression
+    expr = blosc2.lazyexpr("where(where(a2 < 0, 3, a2) > 3, 10, a1)")
+    # Test with eval
+    res = expr.compute()
+    nres = ne_evaluate("where(where(na2 < 0, 3, na2) > 3, 10, na1)")
+    np.testing.assert_allclose(res[:], nres)
+
+    # Test 4: multiplied wheres
+    # Test with string expression
+    expr = blosc2.lazyexpr("1 * where(a2 < 0, 3, a2)")
+    # Test with eval
+    res = expr.compute()
+    nres = ne_evaluate("1 * where(na2 < 0, 3, na2)")
+    np.testing.assert_allclose(res[:], nres)
+
+
 # Test where with one parameter
 def test_where_one_param(array_fixture):
     sa1, sa2, nsa1, nsa2, a1, a2, a3, a4, na1, na2, na3, na4 = array_fixture

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

@@ -428,3 +428,63 @@ def test_reduction_index():
     assert arr[:10].shape == (10,)
     assert arr[0].shape == (1,)
     assert arr.shape == newarr.shape
+
+
+def test_slice_lazy():
+    shape = (20, 20)
+    a = blosc2.linspace(0, 20, num=np.prod(shape), shape=shape)
+    arr = blosc2.lazyexpr("anarr.slice(slice(10,15)) + 1", {"anarr": a})
+    newarr = arr.compute()
+    np.testing.assert_allclose(newarr[:], a.slice(slice(10, 15))[:] + 1)
+
+
+def test_slicebrackets_lazy():
+    shape = (20, 20)
+    a = blosc2.linspace(0, 20, num=np.prod(shape), shape=shape)
+    arr = blosc2.lazyexpr("anarr[10:15] + 1", {"anarr": a})
+    newarr = arr.compute()
+    np.testing.assert_allclose(newarr[:], a[10:15] + 1)
+
+    # Try with getitem
+    a = blosc2.linspace(0, 20, num=np.prod(shape), shape=shape)
+    arr = blosc2.lazyexpr("anarr[10:15] + 1", {"anarr": a})
+    newarr = arr[:3]
+    res = a[10:15] + 1
+    np.testing.assert_allclose(newarr, res[:3])
+
+    # Test other cases
+    arr = blosc2.lazyexpr("anarr[10:15, 2:9] + 1", {"anarr": a})
+    newarr = arr.compute()
+    np.testing.assert_allclose(newarr[:], a[10:15, 2:9] + 1)
+
+    arr = blosc2.lazyexpr("anarr[10:15][2:9] + 1", {"anarr": a})
+    newarr = arr.compute()
+    np.testing.assert_allclose(newarr[:], a[10:15][2:9] + 1)
+
+    arr = blosc2.lazyexpr("anarr[10] + 1", {"anarr": a})
+    newarr = arr.compute()
+    np.testing.assert_allclose(newarr[:], a[10] + 1)
+
+    arr = blosc2.lazyexpr("anarr[10, 1] + 1", {"anarr": a})
+    newarr = arr[:]
+    np.testing.assert_allclose(newarr, a[10, 1] + 1)
+
+
+def test_reduce_string():
+    shape = (10, 10, 2)
+
+    # Create a NDArray from a NumPy array
+    npa = np.linspace(0, 1, np.prod(shape), dtype=np.float32).reshape(shape)
+    npb = np.linspace(1, 2, np.prod(shape), dtype=np.float64).reshape(shape)
+    npc = npa**2 + npb**2 + 2 * npa * npb + 1
+
+    a = blosc2.asarray(npa)
+    b = blosc2.asarray(npb)
+
+    # Get a LazyExpr instance
+    c = a**2 + b**2 + 2 * a * b + 1
+    # Evaluate: output is a NDArray
+    d = blosc2.lazyexpr("sl + c.sum() + a.std()", operands={"a": a, "c": c, "sl": a.slice((1, 1))})
+    sum = d.compute()[()]
+    npsum = npa[1, 1] + np.sum(npc) + np.std(npa)
+    assert np.allclose(sum, npsum)

blosc2-3.3.3/src/blosc2/version.py

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