Merge branch 'main' into fix_out

Author: lshaw8317

.github/workflows/cibuildwheels.yml

@@ -36,27 +36,27 @@ jobs:
           # Linux x86_64 builds
           - os: ubuntu-latest
             arch: x86_64
-            cibw_pattern: "cp3{10,11,12,13}-manylinux*"
+            cibw_pattern: "cp3{10,11,12,13,14}-manylinux*"
             artifact_name: "linux-x86_64"
 
           # Linux ARM64 builds (native runners)
           - os: ubuntu-24.04-arm
             arch: aarch64
-            cibw_pattern: "cp3{10,11,12,13}-manylinux*"
+            cibw_pattern: "cp3{10,11,12,13,14}-manylinux*"
             artifact_name: "linux-aarch64"
             # Don't use native runners for now (looks like wait times are too long)
             #runs-on: ["ubuntu-latest", "arm64"]
 
           # Windows builds
           - os: windows-latest
             arch: x86_64
-            cibw_pattern: "cp3{10,11,12,13}-win64"
+            cibw_pattern: "cp3{10,11,12,13,14}-win64"
             artifact_name: "windows-x86_64"
 
           # macOS builds (universal2)
           - os: macos-latest
             arch: x86_64
-            cibw_pattern: "cp3{10,11,12,13}-macosx*"
+            cibw_pattern: "cp3{10,11,12,13,14}-macosx*"
             artifact_name: "macos-universal2"
     steps:
       - name: Checkout repo

.pre-commit-config.yaml

@@ -9,10 +9,10 @@ repos:
   - repo: https://github.com/pre-commit/pre-commit-hooks
     rev: v6.0.0
     hooks:
+      - id: check-toml
       - id: check-yaml
       - id: end-of-file-fixer
       - id: mixed-line-ending
-      - id: requirements-txt-fixer
       - id: trailing-whitespace
 
   - repo: https://github.com/astral-sh/ruff-pre-commit

pyproject.toml

@@ -28,6 +28,7 @@ classifiers = [
     "Programming Language :: Python :: 3.11",
     "Programming Language :: Python :: 3.12",
     "Programming Language :: Python :: 3.13",
+    "Programming Language :: Python :: 3.14",
 ]
 requires-python = ">=3.10"
 # Follow guidelines from https://scientific-python.org/specs/spec-0000/
@@ -36,7 +37,7 @@ dependencies = [
     "ndindex",
     "msgpack",
     "platformdirs",
-    "numexpr>=2.13.1; platform_machine != 'wasm32'",
+    "numexpr>=2.14.0; platform_machine != 'wasm32'",
     "py-cpuinfo; platform_machine != 'wasm32'",
     "requests",
 ]

src/blosc2/core.py

@@ -1173,7 +1173,10 @@ def get_cache_info(cache_level: int) -> tuple:
     if cache_level == 0:
         cache_level = "1d"
 
-    result = subprocess.run(["lscpu", "--json"], capture_output=True, check=True, text=True)
+    try:
+        result = subprocess.run(["lscpu", "--json"], capture_output=True, check=True, text=True)
+    except (FileNotFoundError, subprocess.CalledProcessError) as err:
+        raise ValueError("lscpu not found or error running lscpu") from err
     lscpu_info = json.loads(result.stdout)
     for entry in lscpu_info["lscpu"]:
         if entry["field"] == f"L{cache_level} cache:":

src/blosc2/lazyexpr.py

@@ -171,6 +171,17 @@ def ne_evaluate(expression, local_dict=None, **kwargs):
 relational_ops = ["==", "!=", "<", "<=", ">", ">="]
 logical_ops = ["&", "|", "^", "~"]
 not_complex_ops = ["maximum", "minimum", "<", "<=", ">", ">="]
+funcs_2args = (
+    "arctan2",
+    "contains",
+    "pow",
+    "power",
+    "nextafter",
+    "copysign",
+    "hypot",
+    "maximum",
+    "minimum",
+)
 
 
 def get_expr_globals(expression):
@@ -2239,23 +2250,22 @@ def __init__(self, new_op):  # noqa: C901
         dtype_ = check_dtype(op, value1, value2)  # perform some checks
         if value2 is None:
             if isinstance(value1, LazyExpr):
-                self.expression = f"{op}({value1.expression})"
+                self.expression = value1.expression if op is None else f"{op}({value1.expression})"
                 self.operands = value1.operands
             else:
                 self.operands = {"o0": value1}
                 self.expression = "o0" if op is None else f"{op}(o0)"
             return
-        elif op in (
-            "arctan2",
-            "contains",
-            "pow",
-            "power",
-            "nextafter",
-            "copysign",
-            "hypot",
-            "maximum",
-            "minimum",
-        ):
+        elif isinstance(value1, LazyExpr) or isinstance(value2, LazyExpr):
+            if isinstance(value1, LazyExpr):
+                newexpr = value1.update_expr(new_op)
+            else:
+                newexpr = value2.update_expr(new_op)
+            self.expression = newexpr.expression
+            self.operands = newexpr.operands
+            self._dtype = newexpr.dtype
+            return
+        elif op in funcs_2args:
             if np.isscalar(value1) and np.isscalar(value2):
                 self.expression = f"{op}({value1}, {value2})"
             elif np.isscalar(value2):
@@ -2268,15 +2278,6 @@ def __init__(self, new_op):  # noqa: C901
                 self.operands = {"o0": value1, "o1": value2}
                 self.expression = f"{op}(o0, o1)"
             return
-        elif isinstance(value1, LazyExpr) or isinstance(value2, LazyExpr):
-            if isinstance(value1, LazyExpr):
-                newexpr = value1.update_expr(new_op)
-            else:
-                newexpr = value2.update_expr(new_op)
-            self.expression = newexpr.expression
-            self.operands = newexpr.operands
-            self._dtype = newexpr.dtype
-            return
 
         self._dtype = dtype_
         if np.isscalar(value1) and np.isscalar(value2):
@@ -2351,51 +2352,64 @@ def update_expr(self, new_op):  # noqa: C901
             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}
-                expression = f"(o0 {op} o1)"
+                expression = "op(o0, o1)" if op in funcs_2args else f"(o0 {op} o1)"
                 return self._new_expr(expression, new_operands, guess=False, out=None, where=None)
             elif isinstance(value1, LazyExpr) and isinstance(value2, LazyExpr):
                 # Expression fusion
                 # Fuse operands in expressions and detect duplicates
                 new_operands, dup_op = fuse_operands(value1.operands, value2.operands)
                 # Take expression 2 and rebase the operands while removing duplicates
                 new_expr = fuse_expressions(value2.expression, len(value1.operands), dup_op)
-                expression = f"({value1.expression} {op} {new_expr})"
-                self.operands = value1.operands
+                expression = (
+                    f"{op}({value1.expression}, {new_expr})"
+                    if op in funcs_2args
+                    else f"({value1.expression} {op} {new_expr})"
+                )
+                def_operands = value1.operands
             elif isinstance(value1, LazyExpr):
-                if op == "~":
-                    expression = f"({op}{value1.expression})"
-                elif np.isscalar(value2):
-                    expression = f"({value1.expression} {op} {value2})"
+                if np.isscalar(value2):
+                    v2 = value2
                 elif hasattr(value2, "shape") and value2.shape == ():
-                    expression = f"({value1.expression} {op} {value2[()]})"
+                    v2 = value2[()]
                 else:
                     operand_to_key = {id(v): k for k, v in value1.operands.items()}
                     try:
-                        op_name = operand_to_key[id(value2)]
+                        v2 = operand_to_key[id(value2)]
                     except KeyError:
-                        op_name = f"o{len(value1.operands)}"
-                        new_operands = {op_name: value2}
-                    expression = f"({value1.expression} {op} {op_name})"
-                self.operands = value1.operands
+                        v2 = f"o{len(value1.operands)}"
+                        new_operands = {v2: value2}
+                if op == "~":
+                    expression = f"({op}{value1.expression})"
+                else:
+                    expression = (
+                        f"{op}({value1.expression}, {v2})"
+                        if op in funcs_2args
+                        else f"({value1.expression} {op} {v2})"
+                    )
+                def_operands = value1.operands
             else:
                 if np.isscalar(value1):
-                    expression = f"({value1} {op} {value2.expression})"
+                    v1 = value1
                 elif hasattr(value1, "shape") and value1.shape == ():
-                    expression = f"({value1[()]} {op} {value2.expression})"
+                    v1 = value1[()]
                 else:
                     operand_to_key = {id(v): k for k, v in value2.operands.items()}
                     try:
-                        op_name = operand_to_key[id(value1)]
+                        v1 = operand_to_key[id(value1)]
                     except KeyError:
-                        op_name = f"o{len(value2.operands)}"
-                        new_operands = {op_name: value1}
-                    if op == "[]":  # syntactic sugar for slicing
-                        expression = f"({op_name}[{value2.expression}])"
-                    else:
-                        expression = f"({op_name} {op} {value2.expression})"
-                    self.operands = value2.operands
+                        v1 = f"o{len(value2.operands)}"
+                        new_operands = {v1: value1}
+                if op == "[]":  # syntactic sugar for slicing
+                    expression = f"({v1}[{value2.expression}])"
+                else:
+                    expression = (
+                        f"{op}({v1}, {value2.expression})"
+                        if op in funcs_2args
+                        else f"({v1} {op} {value2.expression})"
+                    )
+                    def_operands = value2.operands
             # Return a new expression
-            operands = self.operands | new_operands
+            operands = def_operands | new_operands
             expr = self._new_expr(expression, operands, guess=False, out=None, where=None)
             expr._dtype = dtype_  # override dtype with preserved dtype
             return expr

tests/ndarray/test_elementwise_funcs.py

@@ -36,7 +36,7 @@
 SHAPES_CHUNKS_HEAVY = [((10, 13, 13), (3, 5, 2))]
 
 
-def _test_unary_func_impl(np_func, blosc_func, dtype, shape, chunkshape):  # noqa: C901
+def _test_unary_func_impl(np_func, blosc_func, dtype, shape, chunkshape):
     """Helper function containing the actual test logic for unary functions."""
     if np_func.__name__ in ("arccos", "arcsin", "arctanh"):
         a_blosc = blosc2.linspace(
@@ -94,18 +94,6 @@ def _test_unary_func_impl(np_func, blosc_func, dtype, shape, chunkshape):  # noq
                 assert True
             else:
                 raise e
-        except AssertionError as e:
-            if np_func.__name__ in ("tan", "tanh") and dtype == blosc2.complex128:
-                warnings.showwarning(
-                    "tan and tanh do not give correct NaN location",
-                    UserWarning,
-                    __file__,
-                    0,
-                    file=sys.stderr,
-                )
-                pytest.skip("tan and tanh do not give correct NaN location")
-            else:
-                raise e
 
 
 def _test_binary_func_impl(np_func, blosc_func, dtype, shape, chunkshape):  # noqa: C901

tests/ndarray/test_lazyexpr.py

@@ -1440,6 +1440,20 @@ def test_chain_expressions():
     res = expr_final.compute()
     np.testing.assert_allclose(res[:], nres)
 
+    # Test that update_expr does not alter expr1
+    expr1 = "a + b"
+    expr2 = "sin(a) + tan(c)"
+    lexpr1 = blosc2.lazyexpr(expr1)
+    lexpr2 = blosc2.lazyexpr(expr2)
+    lexpr3 = lexpr1 + lexpr2
+    assert lexpr1.expression == lexpr1.expression
+    assert lexpr1.operands == lexpr1.operands
+    assert lexpr2.expression == lexpr2.expression
+    assert lexpr2.operands == lexpr2.operands
+    lexpr1 += lexpr2
+    assert lexpr1.expression == lexpr3.expression
+    assert lexpr1.operands == lexpr3.operands
+
 
 # Test the chaining of multiple persistent lazy expressions
 def test_chain_persistentexpressions():
@@ -1746,3 +1760,11 @@ def test_lazyexpr_compute_out():
     assert lexpr.compute(out=out) is out
     assert out[0] == np.sin(1)
     assert lexpr.compute() is not out
+
+
+def test_lazyexpr_2args():
+    a = blosc2.ones(10)
+    lexpr = blosc2.lazyexpr("sin(a)")
+    newexpr = blosc2.hypot(lexpr, 3)
+    assert newexpr.expression == "hypot((sin(o0)), 3)"
+    assert newexpr.operands["o0"] is a