Tests are passing for all test suite (for numpy>2 at least)

Author: FrancescAlted

src/blosc2/__init__.py

@@ -15,19 +15,13 @@
 
 # Do the platform check once at module level
 IS_WASM = platform.machine() == "wasm32"
-IS_WASM = True  # for testing
+IS_WASM = True  # for testing (comment this line out for production)
 """
 Flag for WebAssembly platform.
 """
 
 if not IS_WASM:
     import numexpr
-else:
-    numexpr = None
-# try:
-#     import numexpr
-# except ImportError:
-#     numexpr = None
 
 from .version import __version__
 

src/blosc2/lazyexpr.py

@@ -40,15 +40,20 @@
 
 # Import numexpr only if not running in WebAssembly
 if not blosc2.IS_WASM:
-    import numexpr as ne
-else:
-    ne = None
+    import numexpr
 
 
 def ne_evaluate(expression, local_dict=None, **kwargs):
     """Safely evaluate expressions using numexpr when possible, falling back to numpy."""
     if local_dict is None:
         local_dict = {}
+    # Get local vars dict from the stack frame
+    _frame_depth = kwargs.pop("_frame_depth", 1)
+    local_dict |= {
+        k: v
+        for k, v in dict(sys._getframe(_frame_depth).f_locals).items()
+        if hasattr(v, "shape") or np.isscalar(v)
+    }
     if blosc2.IS_WASM:
         # Use numpy eval when running in WebAssembly
         safe_globals = {"np": np}
@@ -60,19 +65,12 @@ def ne_evaluate(expression, local_dict=None, **kwargs):
                 if callable(getattr(np, name)) and not name.startswith("_")
             }
         )
-        # Get local vars dict from the stack frame
-        _frame_depth = kwargs.pop("_frame_depth", 1)
-        local_dict |= {
-            k: v
-            for k, v in dict(sys._getframe(_frame_depth).f_locals).items()
-            if hasattr(v, "dtype") or np.isscalar(v)
-        }
         if "out" in kwargs:
             out = kwargs.pop("out")
             out[:] = eval(expression, safe_globals, local_dict)
             return out
         return eval(expression, safe_globals, local_dict)
-    return ne.evaluate(expression, local_dict=local_dict, **kwargs)
+    return numexpr.evaluate(expression, local_dict=local_dict, **kwargs)
 
 
 # All the dtypes that are supported by the expression evaluator

tests/ndarray/test_c2array_expr.py

@@ -7,11 +7,11 @@
 #######################################################################
 import pathlib
 
-import numexpr as ne
 import numpy as np
 import pytest
 
 import blosc2
+from blosc2.lazyexpr import ne_evaluate
 
 pytestmark = pytest.mark.network
 
@@ -58,7 +58,7 @@ def test_simple(chunks_blocks, c2sub_context):
     # Slice
     sl = slice(10)
     expr = a1 + a3
-    nres = ne.evaluate("na1 + na3")
+    nres = ne_evaluate("na1 + na3")
     res = expr.compute(item=sl)
     np.testing.assert_allclose(res[:], nres[sl])
 
@@ -72,7 +72,7 @@ def test_simple_getitem(c2sub_context):
     chunks_blocks = "default"
     a1, a2, a3, a4, na1, na2, na3, na4 = get_arrays(shape, chunks_blocks)
     expr = a1 + a2 - a3 * a4
-    nres = ne.evaluate("na1 + na2 - na3 * na4")
+    nres = ne_evaluate("na1 + na2 - na3 * na4")
 
     # slice
     sl = slice(10)
@@ -99,7 +99,7 @@ def test_ixxx(chunks_blocks, c2sub_context):
     expr /= 7  # __itruediv__
     expr **= 2.3  # __ipow__
     res = expr.compute()
-    nres = ne.evaluate("(((na1 ** 3 + na2 ** 2 + na3 ** 3 - na4 + 3) + 5) / 7) ** 2.3")
+    nres = ne_evaluate("(((na1 ** 3 + na2 ** 2 + na3 ** 3 - na4 + 3) + 5) / 7) ** 2.3")
     np.testing.assert_allclose(res[:], nres)
 
 
@@ -109,7 +109,7 @@ def test_complex(c2sub_context):
     a1, a2, a3, a4, na1, na2, na3, na4 = get_arrays(shape, chunks_blocks)
     expr = blosc2.tan(a1) * blosc2.sin(a2) + (blosc2.sqrt(a4) * 2)
     expr += 2
-    nres = ne.evaluate("tan(na1) * sin(na2) + (sqrt(na4) * 2) + 2")
+    nres = ne_evaluate("tan(na1) * sin(na2) + (sqrt(na4) * 2) + 2")
     # eval
     res = expr.compute()
     np.testing.assert_allclose(res[:], nres)
@@ -139,30 +139,30 @@ def test_mix_operands(chunks_blocks, c2sub_context):
     b3 = blosc2.asarray(na3, chunks=a3.chunks, blocks=a3.blocks)
 
     expr = a1 + b1
-    nres = ne.evaluate("na1 + na1")
+    nres = ne_evaluate("na1 + na1")
     np.testing.assert_allclose(expr[:], nres)
     np.testing.assert_allclose(expr.compute()[:], nres)
 
     expr = a1 + b3
-    nres = ne.evaluate("na1 + na3")
+    nres = ne_evaluate("na1 + na3")
     np.testing.assert_allclose(expr[:], nres)
     np.testing.assert_allclose(expr.compute()[:], nres)
 
     expr = a1 + b1 + a2 + b3
-    nres = ne.evaluate("na1 + na1 + na2 + na3")
+    nres = ne_evaluate("na1 + na1 + na2 + na3")
     np.testing.assert_allclose(expr[:], nres)
     np.testing.assert_allclose(expr.compute()[:], nres)
 
     expr = a1 + a2 + b1 + b3
-    nres = ne.evaluate("na1 + na2 + na1 + na3")
+    nres = ne_evaluate("na1 + na2 + na1 + na3")
     np.testing.assert_allclose(expr[:], nres)
     np.testing.assert_allclose(expr.compute()[:], nres)
 
     # TODO: fix this
     # expr = a1 + na1 * b3
     # print(type(expr))
     # print("expression: ", expr.expression)
-    # nres = ne.evaluate("na1 + na1 * na3")
+    # nres = ne_evaluate("na1 + na1 * na3")
     # np.testing.assert_allclose(expr[:], nres)
     # np.testing.assert_allclose(expr.compute()[:], nres)
 
@@ -174,7 +174,7 @@ def test_save(c2sub_context):
     a1, a2, a3, a4, na1, na2, na3, na4 = get_arrays(shape, (False, True))
 
     expr = a1 * a2 + a3 - a4 * 3
-    nres = ne.evaluate("na1 * na2 + na3 - na4 * 3")
+    nres = ne_evaluate("na1 * na2 + na3 - na4 * 3")
 
     res = expr.compute()
     assert res.dtype == np.float64
@@ -235,7 +235,7 @@ def test_broadcasting(broadcast_fixture):
     assert expr2.shape == np.broadcast_shapes(a1.shape, a2.shape)
     expr = expr1 - expr2
     assert expr.shape == np.broadcast_shapes(a1.shape, a2.shape)
-    nres = ne.evaluate("na1 + na2 - (na1 * na2 + 1)")
+    nres = ne_evaluate("na1 + na2 - (na1 * na2 + 1)")
     res = expr.compute()
     np.testing.assert_allclose(res[:], nres)
     res = expr[:]

tests/ndarray/test_c2array_reductions.py

@@ -7,11 +7,11 @@
 #######################################################################
 import pathlib
 
-import numexpr as ne
 import numpy as np
 import pytest
 
 import blosc2
+from blosc2.lazyexpr import ne_evaluate
 
 pytestmark = pytest.mark.network
 
@@ -50,7 +50,7 @@ def test_reduce_bool(reduce_op, c2sub_context):
     chunks_blocks = "default"
     a1, a2, a3, a4, na1, na2, na3, na4 = get_arrays(shape, chunks_blocks)
     expr = a1 + a2 > a3 * a4
-    nres = ne.evaluate("na1 + na2 > na3 * na4")
+    nres = ne_evaluate("na1 + na2 > na3 * na4")
     res = getattr(expr, reduce_op)()
     nres = getattr(nres, reduce_op)()
     tol = 1e-15 if a1.dtype == "float64" else 1e-6
@@ -105,7 +105,7 @@ def test_reduce_params(chunks_blocks, axis, keepdims, dtype_out, reduce_op, c2su
 
 
 # TODO: "any" and "all" are not supported yet because:
-# ne.evaluate('(o0 + o1)', local_dict = {'o0': np.array(True), 'o1': np.array(True)})
+# ne_evaluate('(o0 + o1)', local_dict = {'o0': np.array(True), 'o1': np.array(True)})
 # is not supported by NumExpr
 @pytest.mark.parametrize(
     "chunks_blocks",

tests/ndarray/test_evaluate.py

@@ -6,11 +6,11 @@
 # LICENSE file in the root directory of this source tree)
 #######################################################################
 
-import numexpr as ne
 import numpy as np
 import pytest
 
 import blosc2
+from blosc2.lazyexpr import ne_evaluate
 
 ###### General expressions
 
@@ -34,25 +34,27 @@ def sample_data(request):
 def test_expr(sample_data):
     a, b, c, shape = sample_data
     d_blosc2 = blosc2.evaluate("((a**3 + sin(a * 2)) < c) & (b > 0)")
-    d_numexpr = ne.evaluate("((a**3 + sin(a * 2)) < c) & (b > 0)")
+    d_numexpr = ne_evaluate("((a**3 + sin(a * 2)) < c) & (b > 0)")
     np.testing.assert_equal(d_blosc2, d_numexpr)
 
 
+# skip this test for WASM for now
+@pytest.mark.skipif(blosc2.IS_WASM, reason="Skip test for WASM")
 def test_expr_out(sample_data):
     a, b, c, shape = sample_data
     # Testing with an out param
     out = blosc2.zeros(shape, dtype="bool")
     d_blosc2 = blosc2.evaluate("((a**3 + sin(a * 2)) < c) & (b > 0)", out=out)
     out2 = np.zeros(shape, dtype=np.bool_)
-    d_numexpr = ne.evaluate("((a**3 + sin(a * 2)) < c) & (b > 0)", out=out2)
+    d_numexpr = ne_evaluate("((a**3 + sin(a * 2)) < c) & (b > 0)", out=out2)
     np.testing.assert_equal(d_blosc2, d_numexpr)
     np.testing.assert_equal(out, out2)
 
 
 def test_expr_optimization(sample_data):
     a, b, c, shape = sample_data
     d_blosc2 = blosc2.evaluate("((a**3 + sin(a * 2)) < c) & (b > 0)", optimization="none")
-    d_numexpr = ne.evaluate("((a**3 + sin(a * 2)) < c) & (b > 0)", optimization="none")
+    d_numexpr = ne_evaluate("((a**3 + sin(a * 2)) < c) & (b > 0)", optimization="none")
     np.testing.assert_equal(d_blosc2, d_numexpr)
 
 

tests/ndarray/test_proxy_expr.py

@@ -7,11 +7,11 @@
 #######################################################################
 import pathlib
 
-import numexpr as ne
 import numpy as np
 import pytest
 
 import blosc2
+from blosc2.lazyexpr import ne_evaluate
 
 pytestmark = pytest.mark.network
 
@@ -68,7 +68,7 @@ def test_expr_proxy_operands(chunks_blocks, c2sub_context):
     sl = slice(10)
     expr = a1 + a2 + a3 + a4
     expr += 3
-    nres = ne.evaluate("na1 + na2 + na3 + na4 + 3")
+    nres = ne_evaluate("na1 + na2 + na3 + na4 + 3")
     res = expr.compute(item=sl)
     np.testing.assert_allclose(res[:], nres[sl])