Add string functionalities for strings in LazyExprs

CMakeLists.txt

@@ -58,7 +58,7 @@ set(MINIEXPR_BUILD_BENCH OFF CACHE BOOL "Build miniexpr benchmarks" FORCE)
 
 FetchContent_Declare(miniexpr
     GIT_REPOSITORY https://github.com/Blosc/miniexpr.git
-    GIT_TAG 77d633cb2c134552da045b8d2cc0ad23908e6b9e
+    GIT_TAG b4cfa9c2dc26772ad2126e6a611f93daf050915f # dsl funcs
 )
 FetchContent_MakeAvailable(miniexpr)
 

src/blosc2/__init__.py

@@ -557,6 +557,7 @@ def _raise(exc):
     cosh,
     count_nonzero,
     divide,
+    endswith,
     equal,
     exp,
     expm1,
@@ -604,6 +605,7 @@ def _raise(exc):
     sqrt,
     square,
     squeeze,
+    startswith,
     std,
     subtract,
     sum,
@@ -724,6 +726,7 @@ def _raise(exc):
     "detect_number_of_cores",
     "divide",
     "dparams_dflts",
+    "endswith",
     "empty",
     "empty_like",
     "equal",
@@ -830,6 +833,7 @@ def _raise(exc):
     "square",
     "squeeze",
     "stack",
+    "startswith",
     "std",
     "storage_dflts",
     "subtract",

src/blosc2/lazyexpr.py

@@ -126,15 +126,33 @@ def ne_evaluate(expression, local_dict=None, **kwargs):
     try:
         return numexpr.evaluate(expression, local_dict=local_dict, **kwargs)
     except ValueError as e:
-        raise e  # unsafe expression
-    except Exception:  # non_numexpr functions present
-        global safe_blosc2_globals
-        res = eval(expression, safe_blosc2_globals, local_dict)
-        if "out" in kwargs:
-            out = kwargs.pop("out")
-            out[:] = res  # will handle calc/decomp if res is lazyarray
-            return out
-        return res[()] if isinstance(res, blosc2.Operand) else res
+        if e.args and e.args[0] == "NumExpr 2 does not support Unicode as a dtype.":
+            pass
+        else:
+            raise e  # unsafe expression
+    except Exception:
+        pass
+    # Try with blosc2 funcs as presence of non-numexpr funcs probably caused failure
+    # ne_evaluate will need safe_blosc2_globals for some functions (e.g. clip, logaddexp)
+    # that are implemented in python-blosc2 not in numexpr
+    global safe_blosc2_globals
+    if len(safe_blosc2_globals) == 0:
+        # First eval call, fill blosc2_safe_globals
+        safe_blosc2_globals = {"blosc2": blosc2}
+        # Add all first-level blosc2 functions
+        safe_blosc2_globals.update(
+            {
+                name: getattr(blosc2, name)
+                for name in dir(blosc2)
+                if callable(getattr(blosc2, name)) and not name.startswith("_")
+            }
+        )
+    res = eval(expression, safe_blosc2_globals, local_dict)
+    if "out" in kwargs:
+        out = kwargs.pop("out")
+        out[:] = res  # will handle calc/decomp if res is lazyarray
+        return out
+    return res[()] if isinstance(res, blosc2.Operand) else res
 
 
 # Define empty ndindex tuple for function defaults
@@ -201,6 +219,8 @@ def ne_evaluate(expression, local_dict=None, **kwargs):
     "hypot",
     "maximum",
     "minimum",
+    "startswith",
+    "endswith",
 )
 
 
@@ -2544,7 +2564,7 @@ def check_dtype(op, value1, value2):
 
 
 def result_type(
-    *arrays_and_dtypes: blosc2.NDArray | int | float | complex | bool | blosc2.dtype,
+    *arrays_and_dtypes: blosc2.NDArray | int | float | complex | bool | str | blosc2.dtype,
 ) -> blosc2.dtype:
     """
     Returns the dtype that results from applying type promotion rules (see Type Promotion Rules) to the arguments.
@@ -2562,7 +2582,7 @@ def result_type(
     # Follow NumPy rules for scalar-array operations
     # Create small arrays with the same dtypes and let NumPy's type promotion determine the result type
     arrs = [
-        value
+        (np.array(value).dtype if isinstance(value, str) else value)
         if (np.isscalar(value) or not hasattr(value, "dtype"))
         else np.array([0], dtype=_convert_dtype(value.dtype))
         for value in arrays_and_dtypes
@@ -2612,6 +2632,8 @@ def __init__(self, new_op):  # noqa: C901
             if not (isinstance(value1, (blosc2.Operand, np.ndarray)) or np.isscalar(value1))
             else value1
         )
+        # Reset values represented as np.int64 etc. to be set as Python natives
+        value1 = value1.item() if np.isscalar(value1) and hasattr(value1, "item") else value1
         if value2 is None:
             if isinstance(value1, LazyExpr):
                 self.expression = value1.expression if op is None else f"{op}({value1.expression})"
@@ -2624,7 +2646,7 @@ def __init__(self, new_op):  # noqa: C901
                 self.operands = value1.operands
             else:
                 if np.isscalar(value1):
-                    value1 = ne_evaluate(f"{op}({value1})")
+                    value1 = ne_evaluate(f"{op}({value1!r})")
                     op = None
                 self.operands = {"o0": value1}
                 self.expression = "o0" if op is None else f"{op}(o0)"
@@ -2634,6 +2656,9 @@ def __init__(self, new_op):  # noqa: C901
             if not (isinstance(value2, (blosc2.Operand, np.ndarray)) or np.isscalar(value2))
             else value2
         )
+        # Reset values represented as np.int64 etc. to be set as Python natives
+        value2 = value2.item() if np.isscalar(value2) and hasattr(value2, "item") else value2
+
         if isinstance(value1, LazyExpr) or isinstance(value2, LazyExpr):
             if isinstance(value1, LazyExpr):
                 newexpr = value1.update_expr(new_op)
@@ -2646,13 +2671,13 @@ def __init__(self, new_op):  # noqa: C901
         elif op in funcs_2args:
             if np.isscalar(value1) and np.isscalar(value2):
                 self.expression = "o0"
-                self.operands = {"o0": ne_evaluate(f"{op}({value1}, {value2})")}  # eager evaluation
+                self.operands = {"o0": ne_evaluate(f"{op}({value1!r}, {value2!r})")}  # eager evaluation
             elif np.isscalar(value2):
                 self.operands = {"o0": value1}
-                self.expression = f"{op}(o0, {value2})"
+                self.expression = f"{op}(o0, {value2!r})"
             elif np.isscalar(value1):
                 self.operands = {"o0": value2}
-                self.expression = f"{op}({value1}, o0)"
+                self.expression = f"{op}({value1!r}, o0)"
             else:
                 self.operands = {"o0": value1, "o1": value2}
                 self.expression = f"{op}(o0, o1)"
@@ -2661,16 +2686,16 @@ def __init__(self, new_op):  # noqa: C901
         self._dtype = dtype_
         if np.isscalar(value1) and np.isscalar(value2):
             self.expression = "o0"
-            self.operands = {"o0": ne_evaluate(f"({value1} {op} {value2})")}  # eager evaluation
+            self.operands = {"o0": ne_evaluate(f"({value1!r} {op} {value2!r})")}  # eager evaluation
         elif np.isscalar(value2):
             self.operands = {"o0": value1}
-            self.expression = f"(o0 {op} {value2})"
+            self.expression = f"(o0 {op} {value2!r})"
         elif hasattr(value2, "shape") and value2.shape == ():
             self.operands = {"o0": value1}
             self.expression = f"(o0 {op} {value2[()]})"
         elif np.isscalar(value1):
             self.operands = {"o0": value2}
-            self.expression = f"({value1} {op} o0)"
+            self.expression = f"({value1!r} {op} o0)"
         elif hasattr(value1, "shape") and value1.shape == ():
             self.operands = {"o0": value2}
             self.expression = f"({value1[()]} {op} o0)"
@@ -3192,22 +3217,7 @@ def find_args(expr):
 
         return value, expression[idx:idx2]
 
-    def _compute_expr(self, item, kwargs):  # noqa : C901
-        # ne_evaluate will need safe_blosc2_globals for some functions (e.g. clip, logaddexp)
-        # that are implemented in python-blosc2 not in numexpr
-        global safe_blosc2_globals
-        if len(safe_blosc2_globals) == 0:
-            # First eval call, fill blosc2_safe_globals for ne_evaluate
-            safe_blosc2_globals = {"blosc2": blosc2}
-            # Add all first-level blosc2 functions
-            safe_blosc2_globals.update(
-                {
-                    name: getattr(blosc2, name)
-                    for name in dir(blosc2)
-                    if callable(getattr(blosc2, name)) and not name.startswith("_")
-                }
-            )
-
+    def _compute_expr(self, item, kwargs):
         if any(method in self.expression for method in eager_funcs):
             # We have reductions in the expression (probably coming from a string lazyexpr)
             # Also includes slice
@@ -3765,7 +3775,7 @@ def _numpy_eval_expr(expression, operands, prefer_blosc=False):
             for key, value in operands.items()
         }
 
-    if "contains" in expression:
+    if np.any([a in expression for a in ["contains", "startswith", "endswith"]]):
         _out = ne_evaluate(expression, local_dict=ops)
     else:
         # Create a globals dict with blosc2 version of functions preferentially