Distinguish between np type hints from Py ones

py/server/deephaven/_udf.py

@@ -240,6 +240,14 @@ def _parse_signature(fn: Callable) -> _ParsedSignature:
         return p_sig
 
 
+def _is_from_np_type(param_types:set[type], np_type_char: str) -> bool:
+    """ Determine if the given numpy type char comes for a numpy type in the given set of parameter type annotations"""
+    for t in param_types:
+        if issubclass(t, np.generic) and np.dtype(t).char == np_type_char:
+            return True
+    return False
+
+
 def _convert_arg(param: _ParsedParamAnnotation, arg: Any) -> Any:
     """ Convert a single argument to the type specified by the annotation """
     if arg is None:
@@ -279,13 +287,21 @@ def _convert_arg(param: _ParsedParamAnnotation, arg: Any) -> Any:
                         else:
                             raise DHError(f"Argument {arg} is not compatible with annotation {param.orig_types}")
                     else:
-                        return np.dtype(param.int_char).type(arg)
+                        # return a numpy integer instance only if the annotation is a numpy type
+                        if _is_from_np_type(param.orig_types, param.int_char):
+                            return np.dtype(param.int_char).type(arg)
+                        else:
+                            return arg
                 elif param.floating_char and isinstance(arg, float):
                     if isinstance(arg, float):
                         if arg == dh_null:
                             return np.nan if "N" not in param.encoded_types else None
                         else:
-                            return np.dtype(param.floating_char).type(arg)
+                            # return a numpy floating instance only if the annotation is a numpy type
+                            if _is_from_np_type(param.orig_types, param.floating_char):
+                                return np.dtype(param.floating_char).type(arg)
+                            else:
+                                return arg
                 elif t == "?" and isinstance(arg, bool):
                     return arg
                 elif t == "M":

py/server/tests/test_udf_numpy_args.py

@@ -392,6 +392,41 @@ def f31(p1: Optional[np.bool_], p2=None) -> bool:
             t2 = t.update(["X1 = f31(null, Y)"])
             self.assertEqual(10, t2.to_string("X1").count("true"))
 
+    def test_non_np_typehints(self):
+        py_types = {"int", "float"}
+
+        for p_type in py_types:
+            with self.subTest(p_type):
+                func_str = f"""
+def f(x: {p_type}) -> bool:  # note typing
+    return type(x) == {p_type}
+"""
+                exec(func_str, globals())
+                t = empty_table(1).update(["X = i", f"Y = f(({p_type})X)"])
+                self.assertEqual(1, t.to_string(cols="Y").count("true"))
+
+
+        np_int_types = {"np.int8", "np.int16", "np.int32", "np.int64"}
+        for p_type in np_int_types:
+            with self.subTest(p_type):
+                func_str = f"""
+def f(x: {p_type}) -> bool:  # note typing
+    return type(x) == {p_type}
+"""
+                exec(func_str, globals())
+                t = empty_table(1).update(["X = i", f"Y = f(X)"])
+                self.assertEqual(1, t.to_string(cols="Y").count("true"))
+
+        np_floating_types = {"np.float32", "np.float64"}
+        for p_type in np_floating_types:
+            with self.subTest(p_type):
+                func_str = f"""
+def f(x: {p_type}) -> bool:  # note typing
+    return type(x) == {p_type}
+"""
+                exec(func_str, globals())
+                t = empty_table(1).update(["X = i", f"Y = f((float)X)"])
+                self.assertEqual(1, t.to_string(cols="Y").count("true"))
 
 if __name__ == "__main__":
     unittest.main()