Disable some tests on windows: miniexpr runtime JIT backend isn't bundled in the windows wheels

Author: FrancescAlted

tests/ndarray/test_dsl_kernels.py

@@ -23,6 +23,35 @@
 clip = np.clip
 
 
+def _jit_backend_available():
+    """Whether the miniexpr runtime JIT backend is bundled in this build.
+
+    The JIT compiler is not shipped on every platform (e.g. the Windows wheels lack
+    it); there a DSL kernel still compiles and runs, but via the interpreter rather
+    than a JIT kernel.  Probe a trivial kernel once so the JIT-specific assertions can
+    be gated on the platform actually having a JIT backend."""
+    try:
+
+        @blosc2.dsl_kernel
+        def _probe(a):
+            return a + 1.0
+
+        return bool(blosc2.validate_dsl_jit(_probe, [np.float64], np.float64).get("jit"))
+    except Exception:
+        return False
+
+
+JIT_AVAILABLE = _jit_backend_available()
+
+
+def _expect_jit(status):
+    """Assert *status* compiled, and that it produced a runtime JIT kernel where the
+    platform actually has a JIT backend (see :func:`_jit_backend_available`)."""
+    assert status["compiled"]
+    if JIT_AVAILABLE:
+        assert status["jit"]
+
+
 @pytest.fixture(autouse=True)
 def _no_auto_js_backend(monkeypatch):
     """Keep this module on the miniexpr/DSL path. Under WebAssembly the default prefers the
@@ -330,9 +359,9 @@ def wrapped_set_pref_expr(self, expression, inputs, fp_accuracy, aux_reduc=None,
     assert "_n1" in captured["expr"]
     assert "_i1" in captured["expr"]
     # ...and it JIT-compiles rather than silently running on the interpreter.
-    assert blosc2.validate_dsl_jit(kernel_index_ramp_float_cast, {"x": np.float32}, np.float32, shape=shape)[
-        "jit"
-    ]
+    _expect_jit(
+        blosc2.validate_dsl_jit(kernel_index_ramp_float_cast, {"x": np.float32}, np.float32, shape=shape)
+    )
 
 
 def test_dsl_kernel_index_symbols_int_cast_matches_expected_ramp():
@@ -463,9 +492,11 @@ def wrapped_set_pref_expr(self, expression, inputs, fp_accuracy, aux_reduc=None,
         assert "range(niter)" not in captured["expr"]
         assert "float(niter)" not in captured["expr"]
         # ...and the loop+scalar kernel JIT-compiles (the original G3 fallback shape).
-        assert blosc2.validate_dsl_jit(
-            kernel_loop_param, {"x": a2.dtype, "y": b2.dtype, "niter": niter}, a2.dtype, shape=(32, 32)
-        )["jit"]
+        _expect_jit(
+            blosc2.validate_dsl_jit(
+                kernel_loop_param, {"x": a2.dtype, "y": b2.dtype, "niter": niter}, a2.dtype, shape=(32, 32)
+            )
+        )
     finally:
         lazyexpr_mod.try_miniexpr = old_try_miniexpr
 
@@ -1097,8 +1128,7 @@ def simple(a, b):
 
     st = blosc2.validate_dsl_jit(simple, [np.float64, np.float64], np.float64)
     assert st["valid"]
-    assert st["compiled"]
-    assert st["jit"]
+    _expect_jit(st)
     assert st["status"] == "ME_COMPILE_SUCCESS"
 
     # A scalar param is inlined (passed as a value); a variable named 'out' (the
@@ -1108,7 +1138,7 @@ def simple(a, b):
         "def withk(a, b, niter):\n    out = a + b * float(niter)\n    return out\n", "withk"
     )
     st = blosc2.validate_dsl_jit(with_out, {"a": np.float64, "b": np.float64, "niter": 3}, np.float64)
-    assert st["jit"]
+    _expect_jit(st)
 
     # Invalid syntax -> not valid, nothing compiled.
     invalid = kernel_from_source("def k(a, b):\n    a = a - b\n    return a\n", "k")