ENH: on failure, the normalizer decorator either raise (default) or return a value

On failure,  @ normalizer without arguments (default) raises, while
@Normalizer(return_or_failure=value) return a specified `value`.

This is useful, e.g. for

@-normalizer
def is_scalar(a: ArrayLike):
   ....

Consider is_scalar(int): the argument cannot be converted to tensor, so
the function returns False. But the actual failure is in the decorator,
so cannot do try-except in the body of the function!

Author: ev-br

torch_np/_normalizations.py

@@ -81,35 +81,49 @@ def normalize_ndarray(arg, name=None):
 
 import functools
 
+_sentinel = object()
 
-def maybe_normalize(arg, parm):
+
+def maybe_normalize(arg, parm, return_on_failure=_sentinel):
     """Normalize arg if a normalizer is registred."""
     normalizer = normalizers.get(parm.annotation, None)
-    return normalizer(arg) if normalizer else arg
-
-
-def normalizer(func):
-    @functools.wraps(func)
-    def wrapped(*args, **kwds):
-        params = inspect.signature(func).parameters
-        first_param = next(iter(params.values()))
-        # NumPy's API does not have positional args before variadic positional args
-        if first_param.kind == inspect.Parameter.VAR_POSITIONAL:
-            args = [maybe_normalize(arg, first_param) for arg in args]
+    try:
+        return normalizer(arg) if normalizer else arg
+    except Exception as exc:
+        if return_on_failure is not _sentinel:
+            return return_on_failure
         else:
-            # NB: extra unknown arguments: pass through, will raise in func(*args) below
-            args = (
-                tuple(
-                    maybe_normalize(arg, parm)
-                    for arg, parm in zip(args, params.values())
+            raise exc from None
+
+
+def normalizer(_func=None, *, return_on_failure=_sentinel):
+    def normalizer_inner(func):
+        @functools.wraps(func)
+        def wrapped(*args, **kwds):
+            params = inspect.signature(func).parameters
+            first_param = next(iter(params.values()))
+            # NumPy's API does not have positional args before variadic positional args
+            if first_param.kind == inspect.Parameter.VAR_POSITIONAL:
+                args = [maybe_normalize(arg, first_param, return_on_failure) for arg in args]
+            else:
+                # NB: extra unknown arguments: pass through, will raise in func(*args) below
+                args = (
+                    tuple(
+                        maybe_normalize(arg, parm, return_on_failure)
+                        for arg, parm in zip(args, params.values())
+                    )
+                    + args[len(params.values()) :]
                 )
-                + args[len(params.values()) :]
-            )
 
-        kwds = {
-            name: maybe_normalize(arg, params[name]) if name in params else arg
-            for name, arg in kwds.items()
-        }
-        return func(*args, **kwds)
+            kwds = {
+                name: maybe_normalize(arg, params[name]) if name in params else arg
+                for name, arg in kwds.items()
+            }
+            return func(*args, **kwds)
+        return wrapped
+
+    if _func is None:
+        return normalizer_inner
+    else:
+        return normalizer_inner(_func)
 
-    return wrapped

torch_np/_wrapper.py

@@ -775,15 +775,12 @@ def i0(x: ArrayLike):
     return _helpers.array_from(result)
 
 
-def isscalar(a):
+@normalizer(return_on_failure=False)
+def isscalar(a: ArrayLike):
     # XXX: this is a stub
-    try:
-        from ._ndarray import asarray
-
-        t = asarray(a).get()
-        return t.numel() == 1
-    except Exception:
-        return False
+    if a is False:
+        return a
+    return a.numel() == 1
 
 
 @normalizer