numpy 2.4.1__pp311-pypy311_pp73-macosx_14_0_arm64.whl

numpy/typing/tests/data/pass/fromnumeric.py

@@ -0,0 +1,272 @@
+"""Tests for :mod:`numpy._core.fromnumeric`."""
+
+import numpy as np
+
+A = np.array(True, ndmin=2, dtype=bool)
+B = np.array(1.0, ndmin=2, dtype=np.float32)
+A.setflags(write=False)
+B.setflags(write=False)
+
+a = np.bool(True)
+b = np.float32(1.0)
+c = 1.0
+d = np.array(1.0, dtype=np.float32)  # writeable
+
+np.take(a, 0)
+np.take(b, 0)
+np.take(c, 0)
+np.take(A, 0)
+np.take(B, 0)
+np.take(A, [0])
+np.take(B, [0])
+
+np.reshape(a, 1)
+np.reshape(b, 1)
+np.reshape(c, 1)
+np.reshape(A, 1)
+np.reshape(B, 1)
+
+np.choose(a, [True, True])
+np.choose(A, [1.0, 1.0])
+
+np.repeat(a, 1)
+np.repeat(b, 1)
+np.repeat(c, 1)
+np.repeat(A, 1)
+np.repeat(B, 1)
+
+np.swapaxes(A, 0, 0)
+np.swapaxes(B, 0, 0)
+
+np.transpose(a)
+np.transpose(b)
+np.transpose(c)
+np.transpose(A)
+np.transpose(B)
+
+np.partition(a, 0, axis=None)
+np.partition(b, 0, axis=None)
+np.partition(c, 0, axis=None)
+np.partition(A, 0)
+np.partition(B, 0)
+
+np.argpartition(a, 0)
+np.argpartition(b, 0)
+np.argpartition(c, 0)
+np.argpartition(A, 0)
+np.argpartition(B, 0)
+
+np.sort(A, 0)
+np.sort(B, 0)
+
+np.argsort(A, 0)
+np.argsort(B, 0)
+
+np.argmax(A)
+np.argmax(B)
+np.argmax(A, axis=0)
+np.argmax(B, axis=0)
+
+np.argmin(A)
+np.argmin(B)
+np.argmin(A, axis=0)
+np.argmin(B, axis=0)
+
+np.searchsorted(A[0], 0)
+np.searchsorted(B[0], 0)
+np.searchsorted(A[0], [0])
+np.searchsorted(B[0], [0])
+
+np.resize(a, (5, 5))
+np.resize(b, (5, 5))
+np.resize(c, (5, 5))
+np.resize(A, (5, 5))
+np.resize(B, (5, 5))
+
+np.squeeze(a)
+np.squeeze(b)
+np.squeeze(c)
+np.squeeze(A)
+np.squeeze(B)
+
+np.diagonal(A)
+np.diagonal(B)
+
+np.trace(A)
+np.trace(B)
+
+np.ravel(a)
+np.ravel(b)
+np.ravel(c)
+np.ravel(A)
+np.ravel(B)
+
+np.nonzero(A)
+np.nonzero(B)
+
+np.shape(a)
+np.shape(b)
+np.shape(c)
+np.shape(A)
+np.shape(B)
+
+np.compress([True], a)
+np.compress([True], b)
+np.compress([True], c)
+np.compress([True], A)
+np.compress([True], B)
+
+np.clip(a, 0, 1.0)
+np.clip(b, -1, 1)
+np.clip(a, 0, None)
+np.clip(b, None, 1)
+np.clip(c, 0, 1)
+np.clip(A, 0, 1)
+np.clip(B, 0, 1)
+np.clip(B, [0, 1], [1, 2])
+
+np.sum(a)
+np.sum(b)
+np.sum(c)
+np.sum(A)
+np.sum(B)
+np.sum(A, axis=0)
+np.sum(B, axis=0)
+
+np.all(a)
+np.all(b)
+np.all(c)
+np.all(A)
+np.all(B)
+np.all(A, axis=0)
+np.all(B, axis=0)
+np.all(A, keepdims=True)
+np.all(B, keepdims=True)
+
+np.any(a)
+np.any(b)
+np.any(c)
+np.any(A)
+np.any(B)
+np.any(A, axis=0)
+np.any(B, axis=0)
+np.any(A, keepdims=True)
+np.any(B, keepdims=True)
+
+np.cumsum(a)
+np.cumsum(b)
+np.cumsum(c)
+np.cumsum(A)
+np.cumsum(B)
+
+np.cumulative_sum(a)
+np.cumulative_sum(b)
+np.cumulative_sum(c)
+np.cumulative_sum(A, axis=0)
+np.cumulative_sum(B, axis=0)
+
+np.ptp(b)
+np.ptp(c)
+np.ptp(B)
+np.ptp(B, axis=0)
+np.ptp(B, keepdims=True)
+
+np.amax(a)
+np.amax(b)
+np.amax(c)
+np.amax(A)
+np.amax(B)
+np.amax(A, axis=0)
+np.amax(B, axis=0)
+np.amax(A, keepdims=True)
+np.amax(B, keepdims=True)
+
+np.amin(a)
+np.amin(b)
+np.amin(c)
+np.amin(A)
+np.amin(B)
+np.amin(A, axis=0)
+np.amin(B, axis=0)
+np.amin(A, keepdims=True)
+np.amin(B, keepdims=True)
+
+np.prod(a)
+np.prod(b)
+np.prod(c)
+np.prod(A)
+np.prod(B)
+np.prod(a, dtype=None)
+np.prod(A, dtype=None)
+np.prod(A, axis=0)
+np.prod(B, axis=0)
+np.prod(A, keepdims=True)
+np.prod(B, keepdims=True)
+np.prod(b, out=d)
+np.prod(B, out=d)
+
+np.cumprod(a)
+np.cumprod(b)
+np.cumprod(c)
+np.cumprod(A)
+np.cumprod(B)
+
+np.cumulative_prod(a)
+np.cumulative_prod(b)
+np.cumulative_prod(c)
+np.cumulative_prod(A, axis=0)
+np.cumulative_prod(B, axis=0)
+
+np.ndim(a)
+np.ndim(b)
+np.ndim(c)
+np.ndim(A)
+np.ndim(B)
+
+np.size(a)
+np.size(b)
+np.size(c)
+np.size(A)
+np.size(B)
+
+np.around(a)
+np.around(b)
+np.around(c)
+np.around(A)
+np.around(B)
+
+np.mean(a)
+np.mean(b)
+np.mean(c)
+np.mean(A)
+np.mean(B)
+np.mean(A, axis=0)
+np.mean(B, axis=0)
+np.mean(A, keepdims=True)
+np.mean(B, keepdims=True)
+np.mean(b, out=d)
+np.mean(B, out=d)
+
+np.std(a)
+np.std(b)
+np.std(c)
+np.std(A)
+np.std(B)
+np.std(A, axis=0)
+np.std(B, axis=0)
+np.std(A, keepdims=True)
+np.std(B, keepdims=True)
+np.std(b, out=d)
+np.std(B, out=d)
+
+np.var(a)
+np.var(b)
+np.var(c)
+np.var(A)
+np.var(B)
+np.var(A, axis=0)
+np.var(B, axis=0)
+np.var(A, keepdims=True)
+np.var(B, keepdims=True)
+np.var(b, out=d)
+np.var(B, out=d)

numpy/typing/tests/data/pass/index_tricks.py

@@ -0,0 +1,62 @@
+from __future__ import annotations
+
+from typing import Any
+
+import numpy as np
+
+AR_LIKE_b = [[True, True], [True, True]]
+AR_LIKE_i = [[1, 2], [3, 4]]
+AR_LIKE_f = [[1.0, 2.0], [3.0, 4.0]]
+AR_LIKE_U = [["1", "2"], ["3", "4"]]
+
+AR_i8: np.ndarray[Any, np.dtype[np.int64]] = np.array(AR_LIKE_i, dtype=np.int64)
+
+np.ndenumerate(AR_i8)
+np.ndenumerate(AR_LIKE_f)
+np.ndenumerate(AR_LIKE_U)
+
+next(np.ndenumerate(AR_i8))
+next(np.ndenumerate(AR_LIKE_f))
+next(np.ndenumerate(AR_LIKE_U))
+
+iter(np.ndenumerate(AR_i8))
+iter(np.ndenumerate(AR_LIKE_f))
+iter(np.ndenumerate(AR_LIKE_U))
+
+iter(np.ndindex(1, 2, 3))
+next(np.ndindex(1, 2, 3))
+
+np.unravel_index([22, 41, 37], (7, 6))
+np.unravel_index([31, 41, 13], (7, 6), order='F')
+np.unravel_index(1621, (6, 7, 8, 9))
+
+np.ravel_multi_index(AR_LIKE_i, (7, 6))
+np.ravel_multi_index(AR_LIKE_i, (7, 6), order='F')
+np.ravel_multi_index(AR_LIKE_i, (4, 6), mode='clip')
+np.ravel_multi_index(AR_LIKE_i, (4, 4), mode=('clip', 'wrap'))
+np.ravel_multi_index((3, 1, 4, 1), (6, 7, 8, 9))
+
+np.mgrid[1:1:2]
+np.mgrid[1:1:2, None:10]
+
+np.ogrid[1:1:2]
+np.ogrid[1:1:2, None:10]
+
+np.index_exp[0:1]
+np.index_exp[0:1, None:3]
+np.index_exp[0, 0:1, ..., [0, 1, 3]]
+
+np.s_[0:1]
+np.s_[0:1, None:3]
+np.s_[0, 0:1, ..., [0, 1, 3]]
+
+np.ix_(AR_LIKE_b[0])
+np.ix_(AR_LIKE_i[0], AR_LIKE_f[0])
+np.ix_(AR_i8[0])
+
+np.fill_diagonal(AR_i8, 5)
+
+np.diag_indices(4)
+np.diag_indices(2, 3)
+
+np.diag_indices_from(AR_i8)

numpy/typing/tests/data/pass/lib_user_array.py

@@ -0,0 +1,22 @@
+"""Based on the `if __name__ == "__main__"` test code in `lib/_user_array_impl.py`."""
+
+from __future__ import annotations
+
+import numpy as np
+from numpy.lib.user_array import container  # type: ignore[deprecated]
+
+N = 10_000
+W = H = int(N**0.5)
+
+a: np.ndarray[tuple[int, int], np.dtype[np.int32]]
+ua: container[tuple[int, int], np.dtype[np.int32]]
+
+a = np.arange(N, dtype=np.int32).reshape(W, H)
+ua = container(a)
+
+ua_small: container[tuple[int, int], np.dtype[np.int32]] = ua[:3, :5]
+ua_small[0, 0] = 10
+
+ua_bool: container[tuple[int, int], np.dtype[np.bool]] = ua_small > 1
+
+# shape: tuple[int, int] = np.shape(ua)

numpy/typing/tests/data/pass/lib_utils.py

@@ -0,0 +1,19 @@
+from __future__ import annotations
+
+from io import StringIO
+
+import numpy as np
+import numpy.lib.array_utils as array_utils
+
+FILE = StringIO()
+AR = np.arange(10, dtype=np.float64)
+
+
+def func(a: int) -> bool:
+    return True
+
+
+array_utils.byte_bounds(AR)
+array_utils.byte_bounds(np.float64())
+
+np.info(1, output=FILE)

numpy/typing/tests/data/pass/lib_version.py

@@ -0,0 +1,18 @@
+from numpy.lib import NumpyVersion
+
+version = NumpyVersion("1.8.0")
+
+version.vstring
+version.version
+version.major
+version.minor
+version.bugfix
+version.pre_release
+version.is_devversion
+
+version == version
+version != version
+version < "1.8.0"
+version <= version
+version > version
+version >= "1.8.0"

numpy/typing/tests/data/pass/literal.py

@@ -0,0 +1,52 @@
+from __future__ import annotations
+
+from functools import partial
+from typing import TYPE_CHECKING, Any
+
+import pytest
+
+import numpy as np
+
+if TYPE_CHECKING:
+    from collections.abc import Callable
+
+AR = np.array(0)
+AR.setflags(write=False)
+
+KACF = frozenset({None, "K", "A", "C", "F"})
+ACF = frozenset({None, "A", "C", "F"})
+CF = frozenset({None, "C", "F"})
+
+order_list: list[tuple[frozenset[str | None], Callable[..., Any]]] = [
+    (KACF, AR.tobytes),
+    (KACF, partial(AR.astype, int)),
+    (KACF, AR.copy),
+    (ACF, partial(AR.reshape, 1)),
+    (KACF, AR.flatten),
+    (KACF, AR.ravel),
+    (KACF, partial(np.array, 1)),
+    # NOTE: __call__ is needed due to mypy bugs (#17620, #17631)
+    (KACF, partial(np.ndarray.__call__, 1)),
+    (CF, partial(np.zeros.__call__, 1)),
+    (CF, partial(np.ones.__call__, 1)),
+    (CF, partial(np.empty.__call__, 1)),
+    (CF, partial(np.full, 1, 1)),
+    (KACF, partial(np.zeros_like, AR)),
+    (KACF, partial(np.ones_like, AR)),
+    (KACF, partial(np.empty_like, AR)),
+    (KACF, partial(np.full_like, AR, 1)),
+    (KACF, partial(np.add.__call__, 1, 1)),  # i.e. np.ufunc.__call__
+    (ACF, partial(np.reshape, AR, 1)),
+    (KACF, partial(np.ravel, AR)),
+    (KACF, partial(np.asarray, 1)),
+    (KACF, partial(np.asanyarray, 1)),
+]
+
+for order_set, func in order_list:
+    for order in order_set:
+        func(order=order)
+
+    invalid_orders = KACF - order_set
+    for order in invalid_orders:
+        with pytest.raises(ValueError):
+            func(order=order)

numpy/typing/tests/data/pass/ma.py

@@ -0,0 +1,199 @@
+import datetime as dt
+from typing import Any, TypeAlias, TypeVar, cast
+
+import numpy as np
+import numpy.typing as npt
+from numpy._typing import _Shape
+
+_ScalarT = TypeVar("_ScalarT", bound=np.generic)
+MaskedArray: TypeAlias = np.ma.MaskedArray[_Shape, np.dtype[_ScalarT]]
+
+# mypy: disable-error-code=no-untyped-call
+
+MAR_b: MaskedArray[np.bool] = np.ma.MaskedArray([True])
+MAR_u: MaskedArray[np.uint32] = np.ma.MaskedArray([1], dtype=np.uint32)
+MAR_i: MaskedArray[np.int64] = np.ma.MaskedArray([1])
+MAR_f: MaskedArray[np.float64] = np.ma.MaskedArray([1.0])
+MAR_c: MaskedArray[np.complex128] = np.ma.MaskedArray([1j])
+MAR_td64: MaskedArray[np.timedelta64] = np.ma.MaskedArray([np.timedelta64(1, "D")])
+MAR_dt64: MaskedArray[np.datetime64] = np.ma.MaskedArray([np.datetime64(1, "D")])
+MAR_S: MaskedArray[np.bytes_] = np.ma.MaskedArray([b'foo'], dtype=np.bytes_)
+MAR_U: MaskedArray[np.str_] = np.ma.MaskedArray(['foo'], dtype=np.str_)
+MAR_T = cast(np.ma.MaskedArray[Any, np.dtypes.StringDType],
+             np.ma.MaskedArray(["a"], dtype="T"))
+MAR_V: MaskedArray[np.void] = np.ma.MaskedArray(
+    [(1, 1)],
+    mask=[(False, False)],
+    dtype=[('a', int), ('b', int)]
+)
+
+AR_b: npt.NDArray[np.bool] = np.array([True, False, True])
+
+AR_LIKE_b = [True]
+AR_LIKE_u = [np.uint32(1)]
+AR_LIKE_i = [1]
+AR_LIKE_f = [1.0]
+AR_LIKE_c = [1j]
+AR_LIKE_m = [np.timedelta64(1, "D")]
+AR_LIKE_M = [np.datetime64(1, "D")]
+
+MAR_f.mask = AR_b
+MAR_f.mask = np.False_
+
+MAR_i.fill_value = 0
+
+MAR_b.flat[MAR_i > 0] = False
+MAR_i.flat[:] = 1
+MAR_f.flat[[0]] = AR_LIKE_f
+MAR_c.flat[[0, 0]] = [3, 4 + 3j]
+MAR_td64.flat[0] = dt.timedelta(1)
+MAR_dt64.flat[0] = dt.datetime(2020, 1, 1)
+
+MAR_b[MAR_i > 0] = False
+MAR_i[:] = 1
+MAR_f[[0]] = AR_LIKE_f
+MAR_c[[0, 0]] = [3, 4 + 3j]
+MAR_td64[0] = dt.timedelta(1)
+MAR_dt64[0] = dt.datetime(2020, 1, 1)
+MAR_V['a'] = [2]
+
+# Inplace addition
+
+MAR_b += AR_LIKE_b
+
+MAR_u += AR_LIKE_b
+MAR_u += AR_LIKE_u
+
+MAR_i += AR_LIKE_b
+MAR_i += 2
+MAR_i += AR_LIKE_i
+
+MAR_f += AR_LIKE_b
+MAR_f += 2
+MAR_f += AR_LIKE_u
+MAR_f += AR_LIKE_i
+MAR_f += AR_LIKE_f
+
+MAR_c += AR_LIKE_b
+MAR_c += AR_LIKE_u
+MAR_c += AR_LIKE_i
+MAR_c += AR_LIKE_f
+MAR_c += AR_LIKE_c
+
+MAR_td64 += AR_LIKE_b
+MAR_td64 += AR_LIKE_u
+MAR_td64 += AR_LIKE_i
+MAR_td64 += AR_LIKE_m
+MAR_dt64 += AR_LIKE_b
+MAR_dt64 += AR_LIKE_u
+MAR_dt64 += AR_LIKE_i
+MAR_dt64 += AR_LIKE_m
+
+MAR_S += b'snakes'
+MAR_U += 'snakes'
+MAR_T += 'snakes'
+
+# Inplace subtraction
+
+MAR_u -= AR_LIKE_b
+MAR_u -= AR_LIKE_u
+
+MAR_i -= AR_LIKE_b
+MAR_i -= AR_LIKE_i
+
+MAR_f -= AR_LIKE_b
+MAR_f -= AR_LIKE_u
+MAR_f -= AR_LIKE_i
+MAR_f -= AR_LIKE_f
+
+MAR_c -= AR_LIKE_b
+MAR_c -= AR_LIKE_u
+MAR_c -= AR_LIKE_i
+MAR_c -= AR_LIKE_f
+MAR_c -= AR_LIKE_c
+
+MAR_td64 -= AR_LIKE_b
+MAR_td64 -= AR_LIKE_u
+MAR_td64 -= AR_LIKE_i
+MAR_td64 -= AR_LIKE_m
+MAR_dt64 -= AR_LIKE_b
+MAR_dt64 -= AR_LIKE_u
+MAR_dt64 -= AR_LIKE_i
+MAR_dt64 -= AR_LIKE_m
+
+# Inplace floor division
+
+MAR_f //= AR_LIKE_b
+MAR_f //= 2
+MAR_f //= AR_LIKE_u
+MAR_f //= AR_LIKE_i
+MAR_f //= AR_LIKE_f
+
+MAR_td64 //= AR_LIKE_i
+
+# Inplace true division
+
+MAR_f /= AR_LIKE_b
+MAR_f /= 2
+MAR_f /= AR_LIKE_u
+MAR_f /= AR_LIKE_i
+MAR_f /= AR_LIKE_f
+
+MAR_c /= AR_LIKE_b
+MAR_c /= AR_LIKE_u
+MAR_c /= AR_LIKE_i
+MAR_c /= AR_LIKE_f
+MAR_c /= AR_LIKE_c
+
+MAR_td64 /= AR_LIKE_i
+
+# Inplace multiplication
+
+MAR_b *= AR_LIKE_b
+
+MAR_u *= AR_LIKE_b
+MAR_u *= AR_LIKE_u
+
+MAR_i *= AR_LIKE_b
+MAR_i *= 2
+MAR_i *= AR_LIKE_i
+
+MAR_f *= AR_LIKE_b
+MAR_f *= 2
+MAR_f *= AR_LIKE_u
+MAR_f *= AR_LIKE_i
+MAR_f *= AR_LIKE_f
+
+MAR_c *= AR_LIKE_b
+MAR_c *= AR_LIKE_u
+MAR_c *= AR_LIKE_i
+MAR_c *= AR_LIKE_f
+MAR_c *= AR_LIKE_c
+
+MAR_td64 *= AR_LIKE_b
+MAR_td64 *= AR_LIKE_u
+MAR_td64 *= AR_LIKE_i
+MAR_td64 *= AR_LIKE_f
+
+MAR_S *= 2
+MAR_U *= 2
+MAR_T *= 2
+
+# Inplace power
+
+MAR_u **= AR_LIKE_b
+MAR_u **= AR_LIKE_u
+
+MAR_i **= AR_LIKE_b
+MAR_i **= AR_LIKE_i
+
+MAR_f **= AR_LIKE_b
+MAR_f **= AR_LIKE_u
+MAR_f **= AR_LIKE_i
+MAR_f **= AR_LIKE_f
+
+MAR_c **= AR_LIKE_b
+MAR_c **= AR_LIKE_u
+MAR_c **= AR_LIKE_i
+MAR_c **= AR_LIKE_f
+MAR_c **= AR_LIKE_c