Merge pull request #19237 from BvB93/multiarray2

ENH: Add annotations to np.core.multiarray part 3/4

8 files changed, 564 insertions, 56 deletions

diff --git a/numpy/__init__.pyi b/numpy/__init__.pyi
index 85ab4e8d8..6e24f6bff 100644
--- a/numpy/__init__.pyi
+++ b/numpy/__init__.pyi
@@ -1,6 +1,8 @@
 import builtins
 import os
 import sys
+import mmap
+import array as _array
 import datetime as dt
 from abc import abstractmethod
 from types import TracebackType
@@ -324,6 +326,21 @@ from numpy.core.multiarray import (
     asanyarray as asanyarray,
     ascontiguousarray as ascontiguousarray,
     asfortranarray as asfortranarray,
+    arange as arange,
+    busday_count as busday_count,
+    busday_offset as busday_offset,
+    compare_chararrays as compare_chararrays,
+    datetime_as_string as datetime_as_string,
+    datetime_data as datetime_data,
+    frombuffer as frombuffer,
+    fromfile as fromfile,
+    fromiter as fromiter,
+    is_busday as is_busday,
+    promote_types as promote_types,
+    seterrobj as seterrobj,
+    geterrobj as geterrobj,
+    fromstring as fromstring,
+    frompyfunc as frompyfunc,
 )
 
 from numpy.core.numeric import (
@@ -609,10 +626,6 @@ class MachAr:
     ) -> None: ...
     def __getattr__(self, key: str) -> Any: ...
 
-class busdaycalendar:
-    def __new__(cls, weekmask: Any = ..., holidays: Any = ...) -> Any: ...
-    def __getattr__(self, key: str) -> Any: ...
-
 class chararray(ndarray[_ShapeType, _DType_co]):
     def __new__(
         subtype,
@@ -876,46 +889,8 @@ def round(a, decimals=..., out=...): ...
 def round_(a, decimals=..., out=...): ...
 def show_config(): ...
 
-# Placeholders for C-based functions
 # TODO: Sort out which parameters are positional-only
-@overload
-def arange(stop, dtype=..., *, like=...): ...
-@overload
-def arange(start, stop, step=..., dtype=..., *, like=...): ...
-def busday_count(
-    begindates,
-    enddates,
-    weekmask=...,
-    holidays=...,
-    busdaycal=...,
-    out=...,
-): ...
-def busday_offset(
-    dates,
-    offsets,
-    roll=...,
-    weekmask=...,
-    holidays=...,
-    busdaycal=...,
-    out=...,
-): ...
-def compare_chararrays(a, b, cmp_op, rstrip): ...
-def datetime_as_string(arr, unit=..., timezone=..., casting=...): ...
-def datetime_data(__dtype): ...
-def frombuffer(buffer, dtype=..., count=..., offset=..., *, like=...): ...
-def fromfile(
-    file, dtype=..., count=..., sep=..., offset=..., *, like=...
-): ...
-def fromiter(iter, dtype, count=..., *, like=...): ...
-def frompyfunc(func, nin, nout, * identity): ...
-def fromstring(string, dtype=..., count=..., sep=..., *, like=...): ...
-def geterrobj(): ...
-def is_busday(
-    dates, weekmask=..., holidays=..., busdaycal=..., out=...
-): ...
-def nested_iters(*args, **kwargs): ...  # TODO: Sort out parameters
-def promote_types(type1, type2): ...
-def seterrobj(errobj): ...
+def nested_iters(*args, **kwargs): ... # TODO: Sort out parameters
 
 _NdArraySubClass = TypeVar("_NdArraySubClass", bound=ndarray)
 _DTypeScalar_co = TypeVar("_DTypeScalar_co", covariant=True, bound=generic)
@@ -1626,7 +1601,18 @@ _DType_co = TypeVar("_DType_co", covariant=True, bound=dtype[Any])
 # have proper shape support
 _ShapeType = TypeVar("_ShapeType", bound=Any)
 _NumberType = TypeVar("_NumberType", bound=number[Any])
-_BufferType = Union[ndarray, bytes, bytearray, memoryview]
+
+# There is currently no exhaustive way to type the buffer protocol,
+# as it is implemented exclusivelly in the C API (python/typing#593)
+_SupportsBuffer = Union[
+    bytes,
+    bytearray,
+    memoryview,
+    _array.array[Any],
+    mmap.mmap,
+    NDArray[Any],
+    generic,
+]
 
 _T = TypeVar("_T")
 _T_co = TypeVar("_T_co", covariant=True)
@@ -1668,7 +1654,7 @@ class ndarray(_ArrayOrScalarCommon, Generic[_ShapeType, _DType_co]):
         cls: Type[_ArraySelf],
         shape: _ShapeLike,
         dtype: DTypeLike = ...,
-        buffer: _BufferType = ...,
+        buffer: _SupportsBuffer = ...,
         offset: int = ...,
         strides: _ShapeLike = ...,
         order: _OrderKACF = ...,
@@ -3736,3 +3722,14 @@ class broadcast:
     def __next__(self) -> Tuple[Any, ...]: ...
     def __iter__(self: _T) -> _T: ...
     def reset(self) -> None: ...
+
+class busdaycalendar:
+    def __new__(
+        cls,
+        weekmask: ArrayLike = ...,
+        holidays: ArrayLike = ...,
+    ) -> busdaycalendar: ...
+    @property
+    def weekmask(self) -> NDArray[bool_]: ...
+    @property
+    def holidays(self) -> NDArray[datetime64]: ...
diff --git a/numpy/core/_add_newdocs.py b/numpy/core/_add_newdocs.py
index 448f6a0c0..15b2b3ad3 100644
--- a/numpy/core/_add_newdocs.py
+++ b/numpy/core/_add_newdocs.py
@@ -1280,7 +1280,7 @@ add_newdoc('numpy.core.multiarray', 'set_typeDict',
 
 add_newdoc('numpy.core.multiarray', 'fromstring',
     """
-    fromstring(string, dtype=float, count=-1, sep='', *, like=None)
+    fromstring(string, dtype=float, count=-1, *, sep, like=None)
 
     A new 1-D array initialized from text data in a string.
 
@@ -1346,16 +1346,16 @@ add_newdoc('numpy.core.multiarray', 'fromstring',
 
 add_newdoc('numpy.core.multiarray', 'compare_chararrays',
     """
-    compare_chararrays(a, b, cmp_op, rstrip)
+    compare_chararrays(a1, a2, cmp, rstrip)
 
     Performs element-wise comparison of two string arrays using the
     comparison operator specified by `cmp_op`.
 
     Parameters
     ----------
-    a, b : array_like
+    a1, a2 : array_like
         Arrays to be compared.
-    cmp_op : {"<", "<=", "==", ">=", ">", "!="}
+    cmp : {"<", "<=", "==", ">=", ">", "!="}
         Type of comparison.
     rstrip : Boolean
         If True, the spaces at the end of Strings are removed before the comparison.
@@ -4475,7 +4475,7 @@ add_newdoc('numpy.core.multiarray', 'ndarray', ('view',
 
 add_newdoc('numpy.core.umath', 'frompyfunc',
     """
-    frompyfunc(func, nin, nout, *[, identity])
+    frompyfunc(func, /, nin, nout, *[, identity])
 
     Takes an arbitrary Python function and returns a NumPy ufunc.
 
@@ -4589,7 +4589,7 @@ add_newdoc('numpy.core.umath', 'geterrobj',
 
 add_newdoc('numpy.core.umath', 'seterrobj',
     """
-    seterrobj(errobj)
+    seterrobj(errobj, /)
 
     Set the object that defines floating-point error handling.
 
diff --git a/numpy/core/multiarray.py b/numpy/core/multiarray.py
index 78aa7a65c..3205f4ecd 100644
--- a/numpy/core/multiarray.py
+++ b/numpy/core/multiarray.py
@@ -31,7 +31,7 @@ __all__ = [
     'busday_count', 'busday_offset', 'busdaycalendar', 'can_cast',
     'compare_chararrays', 'concatenate', 'copyto', 'correlate', 'correlate2',
     'count_nonzero', 'c_einsum', 'datetime_as_string', 'datetime_data',
-    'digitize', 'dot', 'dragon4_positional', 'dragon4_scientific', 'dtype',
+    'dot', 'dragon4_positional', 'dragon4_scientific', 'dtype',
     'empty', 'empty_like', 'error', 'flagsobj', 'flatiter', 'format_longfloat',
     'frombuffer', 'fromfile', 'fromiter', 'fromstring', 'inner',
     'interp', 'interp_complex', 'is_busday', 'lexsort',
diff --git a/numpy/core/multiarray.pyi b/numpy/core/multiarray.pyi
index 30b3f416a..bc33165be 100644
--- a/numpy/core/multiarray.pyi
+++ b/numpy/core/multiarray.pyi
@@ -1,8 +1,13 @@
 # TODO: Sort out any and all missing functions in this namespace
 
+import os
 import sys
+import datetime as dt
 from typing import (
     Any,
+    Callable,
+    IO,
+    Iterable,
     Optional,
     overload,
     TypeVar,
@@ -14,15 +19,24 @@ from typing import (
 )
 
 from numpy import (
+    # Re-exports
     busdaycalendar as busdaycalendar,
-    ndarray,
-    dtype,
+    broadcast as broadcast,
+    dtype as dtype,
+    ndarray as ndarray,
+    nditer as nditer,
+
+    # The rest
+    nditer,
+    ufunc,
     str_,
     bool_,
     uint8,
     intp,
+    int_,
     float64,
     timedelta64,
+    datetime64,
     generic,
     unsignedinteger,
     signedinteger,
@@ -32,6 +46,7 @@ from numpy import (
     _OrderCF,
     _CastingKind,
     _ModeKind,
+    _SupportsBuffer,
 )
 
 from numpy.typing import (
@@ -53,8 +68,14 @@ from numpy.typing import (
     _ArrayLikeFloat_co,
     _ArrayLikeComplex_co,
     _ArrayLikeTD64_co,
+    _ArrayLikeDT64_co,
     _ArrayLikeObject_co,
+    _ArrayLikeStr_co,
+    _ArrayLikeBytes_co,
+    _ScalarLike_co,
     _IntLike_co,
+    _FloatLike_co,
+    _TD64Like_co,
 )
 
 if sys.version_info >= (3, 8):
@@ -65,6 +86,7 @@ else:
 _SCT = TypeVar("_SCT", bound=generic)
 _ArrayType = TypeVar("_ArrayType", bound=NDArray[Any])
 
+# Subscriptable subsets of `npt.DTypeLike` and `npt.ArrayLike`
 _DTypeLike = Union[
     dtype[_SCT],
     Type[_SCT],
@@ -72,6 +94,31 @@ _DTypeLike = Union[
 ]
 _ArrayLike = _NestedSequence[_SupportsArray[dtype[_SCT]]]
 
+# Valid time units
+_UnitKind = L[
+    "Y",
+    "M",
+    "D",
+    "h",
+    "m",
+    "s",
+    "ms",
+    "us", "μs",
+    "ns",
+    "ps",
+    "fs",
+    "as",
+]
+_RollKind = L[  # `raise` is deliberately excluded
+    "nat",
+    "forward",
+    "following",
+    "backward",
+    "preceding",
+    "modifiedfollowing",
+    "modifiedpreceding",
+]
+
 __all__: List[str]
 
 ALLOW_THREADS: Final[int]  # 0 or 1 (system-specific)
@@ -537,3 +584,367 @@ def asfortranarray(
     *,
     like: ArrayLike = ...,
 ) -> NDArray[Any]: ...
+
+# In practice `List[Any]` is list with an int, int and a valid
+# `np.seterrcall()` object
+def geterrobj() -> List[Any]: ...
+def seterrobj(__errobj: List[Any]) -> None: ...
+
+def promote_types(__type1: DTypeLike, __type2: DTypeLike) -> dtype[Any]: ...
+
+# `sep` is a de facto mandatory argument, as its default value is deprecated
+@overload
+def fromstring(
+    string: str | bytes,
+    dtype: None = ...,
+    count: SupportsIndex = ...,
+    *,
+    sep: str,
+    like: ArrayLike = ...,
+) -> NDArray[float64]: ...
+@overload
+def fromstring(
+    string: str | bytes,
+    dtype: _DTypeLike[_SCT],
+    count: SupportsIndex = ...,
+    *,
+    sep: str,
+    like: ArrayLike = ...,
+) -> NDArray[_SCT]: ...
+@overload
+def fromstring(
+    string: str | bytes,
+    dtype: DTypeLike,
+    count: SupportsIndex = ...,
+    *,
+    sep: str,
+    like: ArrayLike = ...,
+) -> NDArray[Any]: ...
+
+def frompyfunc(
+    __func: Callable[..., Any],
+    nin: SupportsIndex,
+    nout: SupportsIndex,
+    *,
+    identity: Any = ...,
+) -> ufunc: ...
+
+@overload
+def fromfile(
+    file: str | bytes | os.PathLike[Any] | IO[Any],
+    dtype: None = ...,
+    count: SupportsIndex = ...,
+    sep: str = ...,
+    offset: SupportsIndex = ...,
+    *,
+    like: ArrayLike = ...,
+) -> NDArray[float64]: ...
+@overload
+def fromfile(
+    file: str | bytes | os.PathLike[Any] | IO[Any],
+    dtype: _DTypeLike[_SCT],
+    count: SupportsIndex = ...,
+    sep: str = ...,
+    offset: SupportsIndex = ...,
+    *,
+    like: ArrayLike = ...,
+) -> NDArray[_SCT]: ...
+@overload
+def fromfile(
+    file: str | bytes | os.PathLike[Any] | IO[Any],
+    dtype: DTypeLike,
+    count: SupportsIndex = ...,
+    sep: str = ...,
+    offset: SupportsIndex = ...,
+    *,
+    like: ArrayLike = ...,
+) -> NDArray[Any]: ...
+
+@overload
+def fromiter(
+    iter: Iterable[Any],
+    dtype: _DTypeLike[_SCT],
+    count: SupportsIndex = ...,
+    *,
+    like: ArrayLike = ...,
+) -> NDArray[_SCT]: ...
+@overload
+def fromiter(
+    iter: Iterable[Any],
+    dtype: DTypeLike,
+    count: SupportsIndex = ...,
+    *,
+    like: ArrayLike = ...,
+) -> NDArray[Any]: ...
+
+@overload
+def frombuffer(
+    buffer: _SupportsBuffer,
+    dtype: None = ...,
+    count: SupportsIndex = ...,
+    offset: SupportsIndex = ...,
+    *,
+    like: ArrayLike = ...,
+) -> NDArray[float64]: ...
+@overload
+def frombuffer(
+    buffer: _SupportsBuffer,
+    dtype: _DTypeLike[_SCT],
+    count: SupportsIndex = ...,
+    offset: SupportsIndex = ...,
+    *,
+    like: ArrayLike = ...,
+) -> NDArray[_SCT]: ...
+@overload
+def frombuffer(
+    buffer: _SupportsBuffer,
+    dtype: DTypeLike,
+    count: SupportsIndex = ...,
+    offset: SupportsIndex = ...,
+    *,
+    like: ArrayLike = ...,
+) -> NDArray[Any]: ...
+
+@overload
+def arange(  # type: ignore[misc]
+    __stop: _IntLike_co,
+    *,
+    dtype: None = ...,
+    like: ArrayLike = ...,
+) -> NDArray[signedinteger[Any]]: ...
+@overload
+def arange(  # type: ignore[misc]
+    start: _IntLike_co,
+    stop: _IntLike_co,
+    step: _IntLike_co = ...,
+    dtype: None = ...,
+    *,
+    like: ArrayLike = ...,
+) -> NDArray[signedinteger[Any]]: ...
+@overload
+def arange(  # type: ignore[misc]
+    __stop: _FloatLike_co,
+    *,
+    dtype: None = ...,
+    like: ArrayLike = ...,
+) -> NDArray[floating[Any]]: ...
+@overload
+def arange(  # type: ignore[misc]
+    start: _FloatLike_co,
+    stop: _FloatLike_co,
+    step: _FloatLike_co = ...,
+    dtype: None = ...,
+    *,
+    like: ArrayLike = ...,
+) -> NDArray[floating[Any]]: ...
+@overload
+def arange(
+    __stop: _TD64Like_co,
+    *,
+    dtype: None = ...,
+    like: ArrayLike = ...,
+) -> NDArray[timedelta64]: ...
+@overload
+def arange(
+    start: _TD64Like_co,
+    stop: _TD64Like_co,
+    step: _TD64Like_co = ...,
+    dtype: None = ...,
+    *,
+    like: ArrayLike = ...,
+) -> NDArray[timedelta64]: ...
+@overload
+def arange(  # both start and stop must always be specified for datetime64
+    start: datetime64,
+    stop: datetime64,
+    step: datetime64 = ...,
+    dtype: None = ...,
+    *,
+    like: ArrayLike = ...,
+) -> NDArray[datetime64]: ...
+@overload
+def arange(
+    __stop: Any,
+    *,
+    dtype: _DTypeLike[_SCT],
+    like: ArrayLike = ...,
+) -> NDArray[_SCT]: ...
+@overload
+def arange(
+    start: Any,
+    stop: Any,
+    step: Any = ...,
+    dtype: _DTypeLike[_SCT] = ...,
+    *,
+    like: ArrayLike = ...,
+) -> NDArray[_SCT]: ...
+@overload
+def arange(
+    __stop: Any,
+    *,
+    dtype: DTypeLike,
+    like: ArrayLike = ...,
+) -> NDArray[Any]: ...
+@overload
+def arange(
+    start: Any,
+    stop: Any,
+    step: Any = ...,
+    dtype: DTypeLike = ...,
+    *,
+    like: ArrayLike = ...,
+) -> NDArray[Any]: ...
+
+def datetime_data(
+    __dtype: str | _DTypeLike[datetime64] | _DTypeLike[timedelta64],
+) -> Tuple[str, int]: ...
+
+# The datetime functions perform unsafe casts to `datetime64[D]`,
+# so a lot of different argument types are allowed here
+
+@overload
+def busday_count(  # type: ignore[misc]
+    begindates: _ScalarLike_co,
+    enddates: _ScalarLike_co,
+    weekmask: ArrayLike = ...,
+    holidays: None | ArrayLike = ...,
+    busdaycal: None | busdaycalendar = ...,
+    out: None = ...,
+) -> int_: ...
+@overload
+def busday_count(  # type: ignore[misc]
+    begindates: ArrayLike,
+    enddates: ArrayLike,
+    weekmask: ArrayLike = ...,
+    holidays: None | ArrayLike = ...,
+    busdaycal: None | busdaycalendar = ...,
+    out: None = ...,
+) -> NDArray[int_]: ...
+@overload
+def busday_count(
+    begindates: ArrayLike,
+    enddates: ArrayLike,
+    weekmask: ArrayLike = ...,
+    holidays: None | ArrayLike = ...,
+    busdaycal: None | busdaycalendar = ...,
+    out: _ArrayType = ...,
+) -> _ArrayType: ...
+
+# `roll="raise"` is (more or less?) equivalent to `casting="safe"`
+@overload
+def busday_offset(  # type: ignore[misc]
+    dates: datetime64,
+    offsets: _TD64Like_co,
+    roll: L["raise"] = ...,
+    weekmask: ArrayLike = ...,
+    holidays: None | ArrayLike = ...,
+    busdaycal: None | busdaycalendar = ...,
+    out: None = ...,
+) -> datetime64: ...
+@overload
+def busday_offset(  # type: ignore[misc]
+    dates: _ArrayLike[datetime64],
+    offsets: _ArrayLikeTD64_co,
+    roll: L["raise"] = ...,
+    weekmask: ArrayLike = ...,
+    holidays: None | ArrayLike = ...,
+    busdaycal: None | busdaycalendar = ...,
+    out: None = ...,
+) -> NDArray[datetime64]: ...
+@overload
+def busday_offset(  # type: ignore[misc]
+    dates: _ArrayLike[datetime64],
+    offsets: _ArrayLike[timedelta64],
+    roll: L["raise"] = ...,
+    weekmask: ArrayLike = ...,
+    holidays: None | ArrayLike = ...,
+    busdaycal: None | busdaycalendar = ...,
+    out: _ArrayType = ...,
+) -> _ArrayType: ...
+@overload
+def busday_offset(  # type: ignore[misc]
+    dates: _ScalarLike_co,
+    offsets: _ScalarLike_co,
+    roll: _RollKind,
+    weekmask: ArrayLike = ...,
+    holidays: None | ArrayLike = ...,
+    busdaycal: None | busdaycalendar = ...,
+    out: None = ...,
+) -> datetime64: ...
+@overload
+def busday_offset(  # type: ignore[misc]
+    dates: ArrayLike,
+    offsets: ArrayLike,
+    roll: _RollKind,
+    weekmask: ArrayLike = ...,
+    holidays: None | ArrayLike = ...,
+    busdaycal: None | busdaycalendar = ...,
+    out: None = ...,
+) -> NDArray[datetime64]: ...
+@overload
+def busday_offset(
+    dates: ArrayLike,
+    offsets: ArrayLike,
+    roll: _RollKind,
+    weekmask: ArrayLike = ...,
+    holidays: None | ArrayLike = ...,
+    busdaycal: None | busdaycalendar = ...,
+    out: _ArrayType = ...,
+) -> _ArrayType: ...
+
+@overload
+def is_busday(  # type: ignore[misc]
+    dates: _ScalarLike_co,
+    weekmask: ArrayLike = ...,
+    holidays: None | ArrayLike = ...,
+    busdaycal: None | busdaycalendar = ...,
+    out: None = ...,
+) -> bool_: ...
+@overload
+def is_busday(  # type: ignore[misc]
+    dates: ArrayLike,
+    weekmask: ArrayLike = ...,
+    holidays: None | ArrayLike = ...,
+    busdaycal: None | busdaycalendar = ...,
+    out: None = ...,
+) -> NDArray[bool_]: ...
+@overload
+def is_busday(
+    dates: ArrayLike,
+    weekmask: ArrayLike = ...,
+    holidays: None | ArrayLike = ...,
+    busdaycal: None | busdaycalendar = ...,
+    out: _ArrayType = ...,
+) -> _ArrayType: ...
+
+@overload
+def datetime_as_string(  # type: ignore[misc]
+    arr: datetime64,
+    unit: None | L["auto"] | _UnitKind = ...,
+    timezone: L["naive", "UTC", "local"] | dt.tzinfo = ...,
+    casting: _CastingKind = ...,
+) -> str_: ...
+@overload
+def datetime_as_string(
+    arr: _ArrayLikeDT64_co,
+    unit: None | L["auto"] | _UnitKind = ...,
+    timezone: L["naive", "UTC", "local"] | dt.tzinfo = ...,
+    casting: _CastingKind = ...,
+) -> NDArray[str_]: ...
+
+@overload
+def compare_chararrays(
+    a1: _ArrayLikeStr_co,
+    a2: _ArrayLikeStr_co,
+    cmp: L["<", "<=", "==", ">=", ">", "!="],
+    rstrip: bool,
+) -> NDArray[bool_]: ...
+@overload
+def compare_chararrays(
+    a1: _ArrayLikeBytes_co,
+    a2: _ArrayLikeBytes_co,
+    cmp: L["<", "<=", "==", ">=", ">", "!="],
+    rstrip: bool,
+) -> NDArray[bool_]: ...
+
+def add_docstring(__obj: Callable[..., Any], __docstring: str) -> None: ...
diff --git a/numpy/typing/tests/data/fail/multiarray.py b/numpy/typing/tests/data/fail/multiarray.py
index e931e9d5c..50361ec43 100644
--- a/numpy/typing/tests/data/fail/multiarray.py
+++ b/numpy/typing/tests/data/fail/multiarray.py
@@ -10,8 +10,12 @@ AR_i8: npt.NDArray[np.int64]
 AR_f8: npt.NDArray[np.float64]
 AR_M: npt.NDArray[np.datetime64]
 
+M: np.datetime64
+
 AR_LIKE_f: List[float]
 
+def func(a: int) -> None: ...
+
 np.where(AR_b, 1)  # E: No overload variant
 
 np.can_cast(AR_f8, 1)  # E: incompatible type
@@ -30,3 +34,16 @@ np.unpackbits(AR_u1, bitorder=">")  # E: incompatible type
 
 np.shares_memory(1, 1, max_work=i8)  # E: incompatible type
 np.may_share_memory(1, 1, max_work=i8)  # E: incompatible type
+
+np.arange(M)  # E: No overload variant
+np.arange(stop=10)  # E: No overload variant
+
+np.datetime_data(int)  # E: incompatible type
+
+np.busday_offset("2012", 10)  # E: incompatible type
+
+np.datetime_as_string("2012")  # E: incompatible type
+
+np.compare_chararrays("a", b"a", "==", False)  # E: No overload variant
+
+np.add_docstring(func, None)  # E: incompatible type
diff --git a/numpy/typing/tests/data/pass/lib_utils.py b/numpy/typing/tests/data/pass/lib_utils.py
index c602923d9..0a15dad22 100644
--- a/numpy/typing/tests/data/pass/lib_utils.py
+++ b/numpy/typing/tests/data/pass/lib_utils.py
@@ -6,7 +6,7 @@ from typing import Any
 import numpy as np
 
 FILE = StringIO()
-AR: np.ndarray[Any, np.dtype[np.float64]] = np.arange(10).astype(np.float64)
+AR = np.arange(10, dtype=np.float64)
 
 def func(a: int) -> bool: ...
 
diff --git a/numpy/typing/tests/data/reveal/array_constructors.py b/numpy/typing/tests/data/reveal/array_constructors.py
index ed966679d..1b9006220 100644
--- a/numpy/typing/tests/data/reveal/array_constructors.py
+++ b/numpy/typing/tests/data/reveal/array_constructors.py
@@ -67,6 +67,41 @@ reveal_type(np.asfortranarray([1, 1.0]))  # E: numpy.ndarray[Any, numpy.dtype[An
 reveal_type(np.asfortranarray(A, dtype=np.int64))  # E: numpy.ndarray[Any, numpy.dtype[{int64}]]
 reveal_type(np.asfortranarray(A, dtype='c16'))  # E: numpy.ndarray[Any, numpy.dtype[Any]]
 
+reveal_type(np.fromstring("1 1 1", sep=" "))  # E: numpy.ndarray[Any, numpy.dtype[{float64}]]
+reveal_type(np.fromstring(b"1 1 1", sep=" "))  # E: numpy.ndarray[Any, numpy.dtype[{float64}]]
+reveal_type(np.fromstring("1 1 1", dtype=np.int64, sep=" "))  # E: numpy.ndarray[Any, numpy.dtype[{int64}]]
+reveal_type(np.fromstring(b"1 1 1", dtype=np.int64, sep=" "))  # E: numpy.ndarray[Any, numpy.dtype[{int64}]]
+reveal_type(np.fromstring("1 1 1", dtype="c16", sep=" "))  # E: numpy.ndarray[Any, numpy.dtype[Any]]
+reveal_type(np.fromstring(b"1 1 1", dtype="c16", sep=" "))  # E: numpy.ndarray[Any, numpy.dtype[Any]]
+
+reveal_type(np.fromfile("test.txt", sep=" "))  # E: numpy.ndarray[Any, numpy.dtype[{float64}]]
+reveal_type(np.fromfile("test.txt", dtype=np.int64, sep=" "))  # E: numpy.ndarray[Any, numpy.dtype[{int64}]]
+reveal_type(np.fromfile("test.txt", dtype="c16", sep=" "))  # E: numpy.ndarray[Any, numpy.dtype[Any]]
+with open("test.txt") as f:
+    reveal_type(np.fromfile(f, sep=" "))  # E: numpy.ndarray[Any, numpy.dtype[{float64}]]
+    reveal_type(np.fromfile(b"test.txt", sep=" "))  # E: numpy.ndarray[Any, numpy.dtype[{float64}]]
+    reveal_type(np.fromfile(Path("test.txt"), sep=" "))  # E: numpy.ndarray[Any, numpy.dtype[{float64}]]
+
+reveal_type(np.fromiter("12345", np.float64))  # E: numpy.ndarray[Any, numpy.dtype[{float64}]]
+reveal_type(np.fromiter("12345", float))  # E: numpy.ndarray[Any, numpy.dtype[Any]]
+
+reveal_type(np.frombuffer(A))  # E: numpy.ndarray[Any, numpy.dtype[{float64}]]
+reveal_type(np.frombuffer(A, dtype=np.int64))  # E: numpy.ndarray[Any, numpy.dtype[{int64}]]
+reveal_type(np.frombuffer(A, dtype="c16"))  # E: numpy.ndarray[Any, numpy.dtype[Any]]
+
+reveal_type(np.arange(False, True))  # E: numpy.ndarray[Any, numpy.dtype[numpy.signedinteger[Any]]]
+reveal_type(np.arange(10))  # E: numpy.ndarray[Any, numpy.dtype[numpy.signedinteger[Any]]]
+reveal_type(np.arange(0, 10, step=2))  # E: numpy.ndarray[Any, numpy.dtype[numpy.signedinteger[Any]]]
+reveal_type(np.arange(10.0))  # E: numpy.ndarray[Any, numpy.dtype[numpy.floating[Any]]]
+reveal_type(np.arange(start=0, stop=10.0))  # E: numpy.ndarray[Any, numpy.dtype[numpy.floating[Any]]]
+reveal_type(np.arange(np.timedelta64(0)))  # E: numpy.ndarray[Any, numpy.dtype[numpy.timedelta64]]
+reveal_type(np.arange(0, np.timedelta64(10)))  # E: numpy.ndarray[Any, numpy.dtype[numpy.timedelta64]]
+reveal_type(np.arange(np.datetime64("0"), np.datetime64("10")))  # E: numpy.ndarray[Any, numpy.dtype[numpy.datetime64]]
+reveal_type(np.arange(10, dtype=np.float64))  # E: numpy.ndarray[Any, numpy.dtype[{float64}]]
+reveal_type(np.arange(0, 10, step=2, dtype=np.int16))  # E: numpy.ndarray[Any, numpy.dtype[{int16}]]
+reveal_type(np.arange(10, dtype=int))  # E: numpy.ndarray[Any, numpy.dtype[Any]]
+reveal_type(np.arange(0, 10, dtype="f8"))  # E: numpy.ndarray[Any, numpy.dtype[Any]]
+
 reveal_type(np.require(A))  # E: numpy.ndarray[Any, numpy.dtype[{float64}]]
 reveal_type(np.require(B))  # E: SubClass[{float64}]
 reveal_type(np.require(B, requirements=None))  # E: SubClass[{float64}]
diff --git a/numpy/typing/tests/data/reveal/multiarray.py b/numpy/typing/tests/data/reveal/multiarray.py
index 2811b1f35..cee51975e 100644
--- a/numpy/typing/tests/data/reveal/multiarray.py
+++ b/numpy/typing/tests/data/reveal/multiarray.py
@@ -1,17 +1,32 @@
-from typing import Any, List
+from typing import Any, List, TypeVar
+from pathlib import Path
+
 import numpy as np
 import numpy.typing as npt
 
+_SCT = TypeVar("_SCT", bound=np.generic, covariant=True)
+
+class SubClass(np.ndarray[Any, np.dtype[_SCT]]): ...
+
+subclass: SubClass[np.float64]
+
 AR_f8: npt.NDArray[np.float64]
 AR_i8: npt.NDArray[np.int64]
 AR_u1: npt.NDArray[np.uint8]
+AR_m: npt.NDArray[np.timedelta64]
+AR_M: npt.NDArray[np.datetime64]
 
 AR_LIKE_f: List[float]
 AR_LIKE_i: List[int]
 
+m: np.timedelta64
+M: np.datetime64
+
 b_f8 = np.broadcast(AR_f8)
 b_i8_f8_f8 = np.broadcast(AR_i8, AR_f8, AR_f8)
 
+def func(a: int) -> bool: ...
+
 reveal_type(next(b_f8))  # E: tuple[Any]
 reveal_type(b_f8.reset())  # E: None
 reveal_type(b_f8.index)  # E: int
@@ -75,3 +90,36 @@ reveal_type(np.shares_memory(AR_f8, AR_f8, max_work=1))  # E: bool
 
 reveal_type(np.may_share_memory(1, 2))  # E: bool
 reveal_type(np.may_share_memory(AR_f8, AR_f8, max_work=1))  # E: bool
+
+reveal_type(np.geterrobj())  # E: list[Any]
+
+reveal_type(np.seterrobj([8192, 521, None]))  # E: None
+
+reveal_type(np.promote_types(np.int32, np.int64))  # E: numpy.dtype[Any]
+reveal_type(np.promote_types("f4", float))  # E: numpy.dtype[Any]
+
+reveal_type(np.frompyfunc(func, 1, 1, identity=None))  # numpy.ufunc
+
+reveal_type(np.datetime_data("m8[D]"))  # E: Tuple[builtins.str, builtins.int]
+reveal_type(np.datetime_data(np.datetime64))  # E: Tuple[builtins.str, builtins.int]
+reveal_type(np.datetime_data(np.dtype(np.timedelta64)))  # E: Tuple[builtins.str, builtins.int]
+
+reveal_type(np.busday_count("2011-01", "2011-02"))  # E: {int_}
+reveal_type(np.busday_count(["2011-01"], "2011-02"))  # E: numpy.ndarray[Any, numpy.dtype[{int_}]]
+
+reveal_type(np.busday_offset(M, m))  # E: numpy.datetime64
+reveal_type(np.busday_offset(M, 5))  # E: numpy.datetime64
+reveal_type(np.busday_offset(AR_M, m))  # E: numpy.ndarray[Any, numpy.dtype[numpy.datetime64]]
+reveal_type(np.busday_offset("2011-01", "2011-02", roll="forward"))  # E: numpy.datetime64
+reveal_type(np.busday_offset(["2011-01"], "2011-02", roll="forward"))  # E: numpy.ndarray[Any, numpy.dtype[numpy.datetime64]]
+
+reveal_type(np.is_busday("2012"))  # E: numpy.bool_
+reveal_type(np.is_busday(["2012"]))  # E: numpy.ndarray[Any, numpy.dtype[numpy.bool_]]
+
+reveal_type(np.datetime_as_string(M))  # E: numpy.str_
+reveal_type(np.datetime_as_string(AR_M))  # E: numpy.ndarray[Any, numpy.dtype[numpy.str_]]
+
+reveal_type(np.compare_chararrays("a", "b", "!=", rstrip=False))  # E: numpy.ndarray[Any, numpy.dtype[numpy.bool_]]
+reveal_type(np.compare_chararrays(b"a", b"a", "==", True))  # E: numpy.ndarray[Any, numpy.dtype[numpy.bool_]]
+
+reveal_type(np.add_docstring(func, "test"))  # E: None