Apply review comments

mtsokol · mtsokol · commit 28e435e601b1 · 2023-11-02T21:38:09.000+01:00
diff --git a/numpy/_core/numerictypes.py b/numpy/_core/numerictypes.py
@@ -396,7 +396,14 @@ def isdtype(input_dtype, kind):
     False
 
     """
-    input_dtype = dtype(input_dtype).type
+    # validate and preprocess arguments
+    if not isinstance(input_dtype, (type, dtype)):
+        raise TypeError(
+            "input_dtype argument must be a dtype, "
+            f"but it is a {type(input_dtype)}."
+        )
+    if isinstance(input_dtype, dtype):
+        input_dtype = input_dtype.type
     input_kinds = kind if isinstance(kind, tuple) else (kind,)
 
     processed_kinds = set()
@@ -420,9 +427,17 @@ def isdtype(input_dtype, kind):
                 sctypes["float"] + sctypes["complex"]
             )
         else:
-            processed_kinds.add(dtype(kind).type)
-
-    return any([input_dtype == k for k in processed_kinds])
+            # validate and preprocess kind
+            if not isinstance(kind, (type, dtype)):
+                raise TypeError(
+                    "kind argument must be comprised of dtypes or "
+                    f"strings only, but it has a {type(kind)}."
+                )
+            if isinstance(kind, dtype):
+                kind = kind.type
+            processed_kinds.add(kind)
+
+    return input_dtype in processed_kinds
 
 
 @set_module('numpy')
diff --git a/numpy/_core/numerictypes.pyi b/numpy/_core/numerictypes.pyi
@@ -110,7 +110,7 @@ def issubclass_(arg1: object, arg2: object) -> L[False]: ...
 def issubsctype(arg1: DTypeLike, arg2: DTypeLike) -> bool: ...
 
 def isdtype(
-    input_dtype: DTypeLike,
+    input_dtype: dtype[Any] | type[Any],
     kind: DTypeLike | tuple[DTypeLike, ...]
 ) -> bool: ...
 
diff --git a/numpy/_core/tests/test_numerictypes.py b/numpy/_core/tests/test_numerictypes.py
@@ -6,7 +6,9 @@
 from numpy._core.numerictypes import (
     issctype, sctype2char, maximum_sctype, sctypes
 )
-from numpy.testing import assert_, assert_equal, assert_raises, IS_PYPY
+from numpy.testing import (
+    assert_, assert_equal, assert_raises, assert_raises_regex, IS_PYPY
+)
 
 # This is the structure of the table used for plain objects:
 #
@@ -416,20 +418,6 @@ def test_nondtype_nonscalartype(self):
         assert np.issubdtype(np.float32, "f")
 
 
-@pytest.mark.parametrize(
-    "dtype,close_dtype",
-    [
-        (np.int64, np.int32), (np.uint64, np.uint32),
-        (np.float64, np.float32), (np.complex128, np.complex64)
-    ]
-)
-@pytest.mark.parametrize(
-    "dtype_group",
-    [
-        None, "signed integer", "unsigned integer", "integral",
-        "real floating", "complex floating", "numeric"
-    ]
-)
 class TestIsDType:
     """
     Check correctness of `np.isdtype`. The test considers different argument
@@ -448,6 +436,20 @@ class TestIsDType:
         )
     }
 
+    @pytest.mark.parametrize(
+        "dtype,close_dtype",
+        [
+            (np.int64, np.int32), (np.uint64, np.uint32),
+            (np.float64, np.float32), (np.complex128, np.complex64)
+        ]
+    )
+    @pytest.mark.parametrize(
+        "dtype_group",
+        [
+            None, "signed integer", "unsigned integer", "integral",
+            "real floating", "complex floating", "numeric"
+        ]
+    )
     def test_isdtype(self, dtype, close_dtype, dtype_group):
         # First check if same dtypes return `true` and different ones
         # give `false` (even if they're close in the dtype hierarchy!)
@@ -464,6 +466,12 @@ def test_isdtype(self, dtype, close_dtype, dtype_group):
         else:
             assert not np.isdtype(dtype, dtype_group)
 
+    def test_isdtype_invalid_args(self):
+        with assert_raises_regex(TypeError, r".*must be a dtype.*"):
+            np.isdtype("int64", np.int64)
+        with assert_raises_regex(TypeError, r".*kind argument must.*"):
+            np.isdtype(np.int64, "int64")
+
 
 class TestSctypeDict:
     def test_longdouble(self):
