dtype and shape are None for missing operators. Fixes pending work in #385.

Author: FrancescAlted

src/blosc2/lazyexpr.py

@@ -1983,10 +1983,16 @@ def dtype(self):
         ):
             # Use the cached dtype
             return self._dtype_
+
+        # Return None if there is a missing operand (e.g. a removed file on disk)
+        if any(v is None for v in self.operands.values()):
+            return None
+
         operands = {
             key: np.ones(np.ones(len(value.shape), dtype=int), dtype=value.dtype)
             for key, value in self.operands.items()
         }
+
         if "contains" in self.expression:
             _out = ne_evaluate(self.expression, local_dict=operands)
         else:
@@ -2019,6 +2025,11 @@ def shape(self):
         ):
             # Use the cached shape
             return self._shape_
+
+        # Return None if there is a missing operand (e.g. a removed file on disk)
+        if any(v is None for v in self.operands.values()):
+            return None
+
         # Operands shape can change, so we always need to recompute this
         _shape, chunks, blocks, fast_path = validate_inputs(self.operands, getattr(self, "_out", None))
         if fast_path:
@@ -3099,11 +3110,16 @@ def _open_lazyarray(array):
             raise TypeError("Error when retrieving the operands")
 
     expr = lazyarray["expression"]
-    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
+    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)
     return new_expr
 
 

tests/ndarray/test_lazyexpr.py

@@ -1307,3 +1307,26 @@ def test_numpy_funcs(array_fixture, func):
     npfunc = getattr(np, func)
     d_numpy = npfunc(((na1**3 + np.sin(na2 * 2)) < na3) & (na2 > 0), axis=0)
     np.testing.assert_equal(d_blosc2, d_numpy)
+
+
+# Test the LazyExpr when some operands are missing (e.g. removed file)
+def test_missing_operator():
+    a = blosc2.arange(10, urlpath="a.b2nd", mode="w")
+    b = blosc2.arange(10, urlpath="b.b2nd", mode="w")
+    expr = blosc2.lazyexpr("a + b")
+    c = expr.save("expr.b2nd", mode="w")
+    # 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
+    assert expr2.expression == "a + b"
+    # Check that dtype and shape are None
+    assert expr2.dtype is None
+    assert expr2.shape is None
+    # Clean up
+    blosc2.remove_urlpath("a.b2nd")
+    blosc2.remove_urlpath("expr.b2nd")