Add lower, upper

Author: lshaw8317

src/blosc2/__init__.py

@@ -649,6 +649,7 @@ def _raise(exc):
     logical_not,
     logical_or,
     logical_xor,
+    lower,
     max,
     maximum,
     mean,
@@ -681,6 +682,7 @@ def _raise(exc):
     tan,
     tanh,
     trunc,
+    upper,
     var,
     where,
 )
@@ -852,6 +854,7 @@ def _raise(exc):
     "logical_not",
     "logical_or",
     "logical_xor",
+    "lower",
     "matmul",
     "matrix_transpose",
     "max",
@@ -923,6 +926,7 @@ def _raise(exc):
     "unpack_array",
     "unpack_array2",
     "unpack_tensor",
+    "upper",
     "validate_expr",
     "var",
     "vecdot",

src/blosc2/ndarray.py

@@ -5048,6 +5048,54 @@ def endswith(
     return blosc2.LazyExpr(new_op=(a, "endswith", suffix))
 
 
+@_incomplete_lazyfunc
+def lower(a: str | blosc2.Array) -> NDArray:
+    """
+    Copy-pasted from numpy documentation: https://numpy.org/doc/stable/reference/generated/numpy.char.lower.html
+    Return an array with the elements converted to lowercase.
+    Call str.lower element-wise.
+    For 8-bit strings, this method is locale-dependent.
+
+    Parameters
+    ----------
+    a : blosc2.Array
+        Input array of bytes_ or str_ dtype
+    kwargs: Any
+        kwargs accepted by the :func:`empty` constructor
+
+    Returns
+    -------
+    out: blosc2.Array, of bytes_ or str_ dtype
+        Has the same shape as element.
+
+    """
+    return blosc2.LazyExpr(new_op=(a, "lower", None))
+
+
+@_incomplete_lazyfunc
+def upper(a: str | blosc2.Array) -> NDArray:
+    """
+    Copy-pasted from numpy documentation: https://numpy.org/doc/stable/reference/generated/numpy.char.upper.html
+    Return an array with the elements converted to uppercase.
+    Call str.lower element-wise.
+    For 8-bit strings, this method is locale-dependent.
+
+    Parameters
+    ----------
+    a : blosc2.Array
+        Input array of bytes_ or str_ dtype
+    kwargs: Any
+        kwargs accepted by the :func:`empty` constructor
+
+    Returns
+    -------
+    out: blosc2.Array, of bytes_ or str_ dtype
+        Has the same shape as element.
+
+    """
+    return blosc2.LazyExpr(new_op=(a, "upper", None))
+
+
 def lazywhere(value1=None, value2=None):
     """Decorator to apply a where condition to a LazyExpr."""
 

src/blosc2/utils.py

@@ -54,6 +54,14 @@ def _string_startswith(a, b):
     return np.char.startswith(a, b)
 
 
+def _string_lower(a):
+    return np.char.lower(a)
+
+
+def _string_upper(a):
+    return np.char.upper(a)
+
+
 def _string_endswith(a, b):
     return np.char.endswith(a, b)
 
@@ -97,6 +105,8 @@ def _format_expr_scalar(value):
 safe_numpy_globals["contains"] = _string_contains
 safe_numpy_globals["startswith"] = _string_startswith
 safe_numpy_globals["endswith"] = _string_endswith
+safe_numpy_globals["upper"] = _string_upper
+safe_numpy_globals["lower"] = _string_lower
 
 
 elementwise_funcs = [
@@ -155,6 +165,7 @@ def _format_expr_scalar(value):
     "logical_not",
     "logical_or",
     "logical_xor",
+    "lower",
     "maximum",
     "minimum",
     "multiply",
@@ -178,6 +189,7 @@ def _format_expr_scalar(value):
     "tan",
     "tanh",
     "trunc",
+    "upper",
     "where",
 ]
 
@@ -931,13 +943,6 @@ def process_key(key, shape):
     return key, mask
 
 
-incomplete_lazyfunc_map = {
-    "contains": lambda *args: np.char.find(*args) != -1,
-    "startswith": lambda *args: np.char.startswith(*args),
-    "endswith": lambda *args: np.char.endswith(*args),
-} | safe_numpy_globals  # clip and logaddexp available in safe_numpy_globals
-
-
 def is_inside_ne_evaluate() -> bool:
     """
     Whether the current code is being executed from an ne_evaluate call
@@ -968,7 +973,7 @@ def filler(inputs_tuple, output, offset):
 
     def wrapper(*args, **kwargs):
         if is_inside_ne_evaluate():  # haven't been able to use miniexpr so use numpy
-            return incomplete_lazyfunc_map[func.__name__](*args, **kwargs)
+            return safe_numpy_globals[func.__name__](*args, **kwargs)
         return func(*args, **kwargs)
 
     return wrapper

tests/ndarray/test_lazyexpr.py

@@ -597,6 +597,41 @@ def test_stringops(values):
         np.testing.assert_array_equal(expr_lazy[:], res_numexpr)
 
 
+def test_stringops2():
+    # test all supported string ops for bytes and strings
+    for t in ("bytes", "string"):
+        if t == "bytes":
+            a1 = np.array([b"abc", b"def", b"aterr", b"oot", b"zu", b"ab c"])
+            a2 = a2_blosc = b"a"
+        else:
+            a1 = np.array(["abc", "def", "aterr", "oot", "zu", "ab c"])
+            a2 = a2_blosc = "a"
+        a1_blosc = blosc2.asarray(a1)
+        for func, npfunc in zip(
+            (blosc2.startswith, blosc2.endswith, blosc2.contains),
+            (np.char.startswith, np.char.endswith, lambda *args: np.char.find(*args) != -1),
+            strict=True,
+        ):
+            expr_lazy = func(a1_blosc, a2_blosc)
+            res_numexpr = npfunc(a1, a2)
+            assert expr_lazy.shape == res_numexpr.shape
+            assert expr_lazy.dtype == blosc2.bool_
+            np.testing.assert_array_equal(expr_lazy[:], res_numexpr)
+
+        np.testing.assert_array_equal((a1_blosc < a2_blosc)[:], a1 < a2)
+        np.testing.assert_array_equal((a1_blosc <= a2_blosc)[:], a1 <= a2)
+        np.testing.assert_array_equal((a1_blosc == a2_blosc)[:], a1 == a2)
+        np.testing.assert_array_equal((a1_blosc != a2_blosc)[:], a1 != a2)
+        np.testing.assert_array_equal((a1_blosc >= a2_blosc)[:], a1 >= a2)
+        np.testing.assert_array_equal((a1_blosc > a2_blosc)[:], a1 > a2)
+
+        for func, npfunc in zip((blosc2.lower, blosc2.upper), (np.char.lower, np.char.upper), strict=True):
+            expr_lazy = func(a1_blosc)
+            res_numexpr = npfunc(a1)
+            assert expr_lazy.shape == res_numexpr.shape
+            np.testing.assert_array_equal(expr_lazy[:], res_numexpr)
+
+
 def test_negate(dtype_fixture, shape_fixture):
     nelems = np.prod(shape_fixture)
     na1 = np.linspace(-1, 1, nelems, dtype=dtype_fixture).reshape(shape_fixture)