Raise error when a lazyexpr misses an operand

Author: jdavid

src/blosc2/exceptions.py

@@ -0,0 +1,8 @@
+
+class MissingOperands(ValueError):
+    def __init__(self, expr, missing_ops):
+        self.expr = expr
+        self.missing_ops = missing_ops
+
+        message = f"Lazy expression \"{expr}\" with missing operands: {missing_ops}"
+        super().__init__(message)

src/blosc2/lazyexpr.py

@@ -29,6 +29,8 @@
 
 from numpy.exceptions import ComplexWarning
 
+from . import exceptions
+
 if TYPE_CHECKING:
     from collections.abc import Callable, Sequence
 
@@ -3294,14 +3296,16 @@ def _open_lazyarray(array):
     operands = lazyarray["operands"]
     parent_path = Path(array.schunk.urlpath).parent
     operands_dict = {}
+    missing_ops = {}
     for key, value in operands.items():
         if isinstance(value, str):
             value = parent_path / value
             try:
                 op = blosc2.open(value)
             except FileNotFoundError:
-                op = None
-            operands_dict[key] = op
+                missing_ops[key] = value
+            else:
+                operands_dict[key] = op
         elif isinstance(value, dict):
             # C2Array
             operands_dict[key] = blosc2.C2Array(
@@ -3312,16 +3316,17 @@ def _open_lazyarray(array):
             raise TypeError("Error when retrieving the operands")
 
     expr = lazyarray["expression"]
-    try:
-        new_expr = LazyExpr._new_expr(expr, operands_dict, guess=True, out=None, where=None)
-        # Make the array info available for the user (only available when opened from disk)
-        new_expr.array = array
-        # We want to expose schunk too, so that .info() can be used on the LazyArray
-        new_expr.schunk = array.schunk
-    except RuntimeError:
-        # Something unexpected happened. Avoid guessing and return something that
-        # can be introspected.
-        new_expr = LazyExpr._new_expr(expr, operands_dict, guess=False, out=None, where=None)
+    if missing_ops:
+        exc = exceptions.MissingOperands(expr, missing_ops)
+        exc.expr = expr
+        exc.missing_ops = missing_ops
+        raise exc
+
+    new_expr = LazyExpr._new_expr(expr, operands_dict, guess=True, out=None, where=None)
+    # Make the array info available for the user (only available when opened from disk)
+    new_expr.array = array
+    # We want to expose schunk too, so that .info() can be used on the LazyArray
+    new_expr.schunk = array.schunk
     return new_expr
 
 

tests/ndarray/test_lazyexpr.py

@@ -6,6 +6,7 @@
 # LICENSE file in the root directory of this source tree)
 #######################################################################
 import math
+import pathlib
 
 import numpy as np
 import pytest
@@ -1344,17 +1345,14 @@ def test_missing_operator():
     # Remove the file for operand b
     blosc2.remove_urlpath("b.b2nd")
     # Re-open the lazy expression
-    expr2 = blosc2.open("expr.b2nd")
-    # Check that some operand is missing
-    assert expr2.operands["a"] is not None
-    assert expr2.operands["b"] is None
-    # Check that the expression is still there, and can be introspected
-    # Note the added parentheses. The parser automatically adds these,
-    # mainly because of possible operator precedence issues in nested expressions.
-    assert expr2.expression == "a + b"
-    # Check that dtype and shape are None
-    assert expr2.dtype is None
-    assert expr2.shape is None
+    with pytest.raises(blosc2.exceptions.MissingOperands) as excinfo:
+        blosc2.open("expr.b2nd")
+
+    # Check that some operand is missing"
+    assert "a" not in excinfo.value.missing_ops
+    assert excinfo.value.missing_ops["b"] == pathlib.Path("b.b2nd")
+    assert excinfo.value.expr == "a + b"
+
     # Clean up
     blosc2.remove_urlpath("a.b2nd")
     blosc2.remove_urlpath("expr.b2nd")