numpy 2.3.2__cp313-cp313t-win_arm64.whl → 2.3.4__cp313-cp313t-win_arm64.whl

numpy/_core/_ufunc_config.py

@@ -187,6 +187,8 @@ def setbufsize(size):
     8192
 
     """
+    if size < 0:
+        raise ValueError("buffer size must be non-negative")
     old = _get_extobj_dict()["bufsize"]
     extobj = _make_extobj(bufsize=size)
     _extobj_contextvar.set(extobj)

numpy/_core/_ufunc_config.pyi

@@ -1,13 +1,31 @@
 from collections.abc import Callable
-from typing import Any, Literal, TypeAlias, TypedDict, type_check_only
+from types import TracebackType
+from typing import (
+    Any,
+    Final,
+    Literal,
+    TypeAlias,
+    TypedDict,
+    TypeVar,
+    type_check_only,
+)
 
 from _typeshed import SupportsWrite
 
-from numpy import errstate as errstate
+__all__ = [
+    "seterr",
+    "geterr",
+    "setbufsize",
+    "getbufsize",
+    "seterrcall",
+    "geterrcall",
+    "errstate",
+]
 
 _ErrKind: TypeAlias = Literal["ignore", "warn", "raise", "call", "print", "log"]
-_ErrFunc: TypeAlias = Callable[[str, int], Any]
-_ErrCall: TypeAlias = _ErrFunc | SupportsWrite[str]
+_ErrCall: TypeAlias = Callable[[str, int], Any] | SupportsWrite[str]
+
+_CallableT = TypeVar("_CallableT", bound=Callable[..., object])
 
 @type_check_only
 class _ErrDict(TypedDict):
@@ -16,6 +34,36 @@ class _ErrDict(TypedDict):
     under: _ErrKind
     invalid: _ErrKind
 
+###
+
+class _unspecified: ...
+
+_Unspecified: Final[_unspecified]
+
+class errstate:
+    __slots__ = "_all", "_call", "_divide", "_invalid", "_over", "_token", "_under"
+
+    def __init__(
+        self,
+        /,
+        *,
+        call: _ErrCall | _unspecified = ...,  # = _Unspecified
+        all: _ErrKind | None = None,
+        divide: _ErrKind | None = None,
+        over: _ErrKind | None = None,
+        under: _ErrKind | None = None,
+        invalid: _ErrKind | None = None,
+    ) -> None: ...
+    def __call__(self, /, func: _CallableT) -> _CallableT: ...
+    def __enter__(self) -> None: ...
+    def __exit__(
+        self,
+        exc_type: type[BaseException] | None,
+        exc_value: BaseException | None,
+        traceback: TracebackType | None,
+        /,
+    ) -> None: ...
+
 def seterr(
     all: _ErrKind | None = ...,
     divide: _ErrKind | None = ...,
@@ -28,5 +76,3 @@ def setbufsize(size: int) -> int: ...
 def getbufsize() -> int: ...
 def seterrcall(func: _ErrCall | None) -> _ErrCall | None: ...
 def geterrcall() -> _ErrCall | None: ...
-
-# See `numpy/__init__.pyi` for the `errstate` class and `no_nep5_warnings`

numpy/_core/lib/pkgconfig/numpy.pc

@@ -3,5 +3,5 @@ includedir=${prefix}/include
 
 Name: numpy
 Description: NumPy is the fundamental package for scientific computing with Python.
-Version: 2.3.2
+Version: 2.3.4
 Cflags: -I${includedir}

numpy/_core/numerictypes.py

@@ -598,7 +598,7 @@ def _scalar_type_key(typ):
 
 
 ScalarType = [int, float, complex, bool, bytes, str, memoryview]
-ScalarType += sorted(set(sctypeDict.values()), key=_scalar_type_key)
+ScalarType += sorted(dict.fromkeys(sctypeDict.values()), key=_scalar_type_key)
 ScalarType = tuple(ScalarType)
 
 

numpy/_core/tests/test_api.py

@@ -91,7 +91,7 @@ def test_array_array():
     # instead we get a array([...], dtype=">V18")
     assert_equal(bytes(np.array(o).data), bytes(a.data))
 
-    # test array
+    # test __array__
     def custom__array__(self, dtype=None, copy=None):
         return np.array(100.0, dtype=dtype, copy=copy)
 
@@ -157,6 +157,39 @@ def test_array_array():
     assert_equal(np.array([(1.0,) * 10] * 10, dtype=np.float64),
                  np.ones((10, 10), dtype=np.float64))
 
+
+@pytest.mark.skipif(not HAS_REFCOUNT, reason="Python lacks refcounts")
+def test___array___refcount():
+    class MyArray:
+        def __init__(self, dtype):
+            self.val = np.array(-1, dtype=dtype)
+
+        def __array__(self, dtype=None, copy=None):
+            return self.val.__array__(dtype=dtype, copy=copy)
+
+    # test all possible scenarios:
+    # dtype(none | same | different) x copy(true | false | none)
+    dt = np.dtype(np.int32)
+    old_refcount = sys.getrefcount(dt)
+    np.array(MyArray(dt))
+    assert_equal(old_refcount, sys.getrefcount(dt))
+    np.array(MyArray(dt), dtype=dt)
+    assert_equal(old_refcount, sys.getrefcount(dt))
+    np.array(MyArray(dt), copy=None)
+    assert_equal(old_refcount, sys.getrefcount(dt))
+    np.array(MyArray(dt), dtype=dt, copy=None)
+    assert_equal(old_refcount, sys.getrefcount(dt))
+    dt2 = np.dtype(np.int16)
+    old_refcount2 = sys.getrefcount(dt2)
+    np.array(MyArray(dt), dtype=dt2)
+    assert_equal(old_refcount2, sys.getrefcount(dt2))
+    np.array(MyArray(dt), dtype=dt2, copy=None)
+    assert_equal(old_refcount2, sys.getrefcount(dt2))
+    with pytest.raises(ValueError):
+        np.array(MyArray(dt), dtype=dt2, copy=False)
+    assert_equal(old_refcount2, sys.getrefcount(dt2))
+
+
 @pytest.mark.parametrize("array", [True, False])
 def test_array_impossible_casts(array):
     # All builtin types can be forcibly cast, at least theoretically,

numpy/_core/tests/test_datetime.py

@@ -844,6 +844,21 @@ class TestDateTime:
         a = np.array([-1, 'NaT', 1234567], dtype='<m')
         assert_equal(str(a), "[     -1   'NaT' 1234567]")
 
+    def test_timedelta_array_with_nats(self):
+        # Regression test for gh-29497.
+        x = np.array([np.timedelta64('nat'),
+                      np.timedelta64('nat', 's'),
+                      np.timedelta64('nat', 'ms'),
+                      np.timedelta64(123, 'ms')])
+        for td in x[:3]:
+            assert np.isnat(td)
+
+    def test_timedelta_array_nat_assignment(self):
+        # Regression test for gh-29497.
+        x = np.zeros(3, dtype='m8[ms]')
+        x[1] = np.timedelta64('nat', 's')
+        assert np.isnat(x[1])
+
     def test_pickle(self):
         # Check that pickle roundtripping works
         for proto in range(2, pickle.HIGHEST_PROTOCOL + 1):
@@ -872,6 +887,15 @@ class TestDateTime:
               b"I1\nI1\nI1\ntp7\ntp8\ntp9\nb."
         assert_equal(pickle.loads(pkl), np.dtype('>M8[us]'))
 
+    def test_gh_29555(self):
+        # check that dtype metadata round-trips when none
+        dt = np.dtype('>M8[us]')
+        assert dt.metadata is None
+        for proto in range(2, pickle.HIGHEST_PROTOCOL + 1):
+            res = pickle.loads(pickle.dumps(dt, protocol=proto))
+            assert_equal(res, dt)
+            assert res.metadata is None
+
     def test_setstate(self):
         "Verify that datetime dtype __setstate__ can handle bad arguments"
         dt = np.dtype('>M8[us]')

numpy/_core/tests/test_numerictypes.py

@@ -617,6 +617,35 @@ class TestScalarTypeNames:
         assert np.dtype(t.__name__).type is t
 
 
+class TestScalarTypeOrder:
+    @pytest.mark.parametrize(('a', 'b'), [
+        # signedinteger
+        (np.byte, np.short),
+        (np.short, np.intc),
+        (np.intc, np.long),
+        (np.long, np.longlong),
+        # unsignedinteger
+        (np.ubyte, np.ushort),
+        (np.ushort, np.uintc),
+        (np.uintc, np.ulong),
+        (np.ulong, np.ulonglong),
+        # floating
+        (np.half, np.single),
+        (np.single, np.double),
+        (np.double, np.longdouble),
+        # complexfloating
+        (np.csingle, np.cdouble),
+        (np.cdouble, np.clongdouble),
+        # flexible
+        (np.bytes_, np.str_),
+        (np.str_, np.void),
+        # bouncy castles
+        (np.datetime64, np.timedelta64),
+    ])
+    def test_stable_ordering(self, a: type[np.generic], b: type[np.generic]):
+        assert np.ScalarType.index(a) <= np.ScalarType.index(b)
+
+
 class TestBoolDefinition:
     def test_bool_definition(self):
         assert nt.bool is np.bool

numpy/_core/tests/test_stringdtype.py

@@ -531,6 +531,13 @@ def test_fancy_indexing(string_list):
         assert_array_equal(sarr[ind], uarr[ind])
 
 
+def test_flatiter_indexing():
+    # see gh-29659
+    arr = np.array(['hello', 'world'], dtype='T')
+    arr.flat[:] = 9223372036854775
+    assert_array_equal(arr, np.array([9223372036854775] * 2, dtype='T'))
+
+
 def test_creation_functions():
     assert_array_equal(np.zeros(3, dtype="T"), ["", "", ""])
     assert_array_equal(np.empty(3, dtype="T"), ["", "", ""])
@@ -1624,17 +1631,17 @@ class TestImplementation:
     """
 
     @classmethod
-    def setup_class(self):
-        self.MISSING = 0x80
-        self.INITIALIZED = 0x40
-        self.OUTSIDE_ARENA = 0x20
-        self.LONG = 0x10
-        self.dtype = StringDType(na_object=np.nan)
-        self.sizeofstr = self.dtype.itemsize
-        sp = self.dtype.itemsize // 2  # pointer size = sizeof(size_t)
+    def setup_class(cls):
+        cls.MISSING = 0x80
+        cls.INITIALIZED = 0x40
+        cls.OUTSIDE_ARENA = 0x20
+        cls.LONG = 0x10
+        cls.dtype = StringDType(na_object=np.nan)
+        cls.sizeofstr = cls.dtype.itemsize
+        sp = cls.dtype.itemsize // 2  # pointer size = sizeof(size_t)
         # Below, size is not strictly correct, since it really uses
         # 7 (or 3) bytes, but good enough for the tests here.
-        self.view_dtype = np.dtype([
+        cls.view_dtype = np.dtype([
             ('offset', f'u{sp}'),
             ('size', f'u{sp // 2}'),
             ('xsiz', f'V{sp // 2 - 1}'),
@@ -1645,13 +1652,13 @@ class TestImplementation:
             ('size', f'u{sp // 2}'),
             ('offset', f'u{sp}'),
         ])
-        self.s_empty = ""
-        self.s_short = "01234"
-        self.s_medium = "abcdefghijklmnopqrstuvwxyz"
-        self.s_long = "-=+" * 100
-        self.a = np.array(
-            [self.s_empty, self.s_short, self.s_medium, self.s_long],
-            self.dtype)
+        cls.s_empty = ""
+        cls.s_short = "01234"
+        cls.s_medium = "abcdefghijklmnopqrstuvwxyz"
+        cls.s_long = "-=+" * 100
+        cls.a = np.array(
+            [cls.s_empty, cls.s_short, cls.s_medium, cls.s_long],
+            cls.dtype)
 
     def get_view(self, a):
         # Cannot view a StringDType as anything else directly, since

numpy/_core/tests/test_strings.py

@@ -4,6 +4,7 @@ import sys
 import pytest
 
 import numpy as np
+from numpy._core._exceptions import _UFuncNoLoopError
 from numpy.testing import IS_PYPY, assert_array_equal, assert_raises
 from numpy.testing._private.utils import requires_memory
 
@@ -821,6 +822,20 @@ class TestMethods:
             np.strings.expandtabs(np.array("\ta\n\tb", dtype=dt), sys.maxsize)
             np.strings.expandtabs(np.array("\ta\n\tb", dtype=dt), 2**61)
 
+    def test_expandtabs_length_not_cause_segfault(self, dt):
+        # see gh-28829
+        with pytest.raises(
+            _UFuncNoLoopError,
+            match="did not contain a loop with signature matching types",
+        ):
+            np._core.strings._expandtabs_length.reduce(np.zeros(200))
+
+        with pytest.raises(
+            _UFuncNoLoopError,
+            match="did not contain a loop with signature matching types",
+        ):
+            np.strings.expandtabs(np.zeros(200))
+
     FILL_ERROR = "The fill character must be exactly one character long"
 
     def test_center_raises_multiple_character_fill(self, dt):

numpy/_core/tests/test_umath.py

@@ -4704,6 +4704,18 @@ def test_reduceat():
     np.setbufsize(ncu.UFUNC_BUFSIZE_DEFAULT)
     assert_array_almost_equal(h1, h2)
 
+def test_negative_value_raises():
+    with pytest.raises(ValueError, match="buffer size must be non-negative"):
+        np.setbufsize(-5)
+
+    old = np.getbufsize()
+    try:
+        prev = np.setbufsize(4096)
+        assert prev == old
+        assert np.getbufsize() == 4096
+    finally:
+        np.setbufsize(old)
+
 def test_reduceat_empty():
     """Reduceat should work with empty arrays"""
     indices = np.array([], 'i4')

numpy/exceptions.pyi

@@ -17,6 +17,8 @@ class TooHardError(RuntimeError): ...
 class DTypePromotionError(TypeError): ...
 
 class AxisError(ValueError, IndexError):
+    __slots__ = "_msg", "axis", "ndim"
+
     axis: int | None
     ndim: int | None
     @overload

numpy/lib/_arraysetops_impl.pyi

@@ -102,6 +102,7 @@ def unique(
     axis: SupportsIndex | None = None,
     *,
     equal_nan: bool = True,
+    sorted: bool = True,
 ) -> NDArray[_ScalarT]: ...
 @overload  # unknown scalar-type, FFF
 def unique(
@@ -112,6 +113,7 @@ def unique(
     axis: SupportsIndex | None = None,
     *,
     equal_nan: bool = True,
+    sorted: bool = True,
 ) -> _AnyArray: ...
 @overload  # known scalar-type, TFF
 def unique(
@@ -122,6 +124,7 @@ def unique(
     axis: SupportsIndex | None = None,
     *,
     equal_nan: bool = True,
+    sorted: bool = True,
 ) -> tuple[NDArray[_ScalarT], _IntArray]: ...
 @overload  # unknown scalar-type, TFF
 def unique(
@@ -132,6 +135,7 @@ def unique(
     axis: SupportsIndex | None = None,
     *,
     equal_nan: bool = True,
+    sorted: bool = True,
 ) -> tuple[_AnyArray, _IntArray]: ...
 @overload  # known scalar-type, FTF (positional)
 def unique(
@@ -142,6 +146,7 @@ def unique(
     axis: SupportsIndex | None = None,
     *,
     equal_nan: bool = True,
+    sorted: bool = True,
 ) -> tuple[NDArray[_ScalarT], _IntArray]: ...
 @overload  # known scalar-type, FTF (keyword)
 def unique(
@@ -152,6 +157,7 @@ def unique(
     return_counts: L[False] = False,
     axis: SupportsIndex | None = None,
     equal_nan: bool = True,
+    sorted: bool = True,
 ) -> tuple[NDArray[_ScalarT], _IntArray]: ...
 @overload  # unknown scalar-type, FTF (positional)
 def unique(
@@ -162,6 +168,7 @@ def unique(
     axis: SupportsIndex | None = None,
     *,
     equal_nan: bool = True,
+    sorted: bool = True,
 ) -> tuple[_AnyArray, _IntArray]: ...
 @overload  # unknown scalar-type, FTF (keyword)
 def unique(
@@ -172,6 +179,7 @@ def unique(
     return_counts: L[False] = False,
     axis: SupportsIndex | None = None,
     equal_nan: bool = True,
+    sorted: bool = True,
 ) -> tuple[_AnyArray, _IntArray]: ...
 @overload  # known scalar-type, FFT (positional)
 def unique(
@@ -182,6 +190,7 @@ def unique(
     axis: SupportsIndex | None = None,
     *,
     equal_nan: bool = True,
+    sorted: bool = True,
 ) -> tuple[NDArray[_ScalarT], _IntArray]: ...
 @overload  # known scalar-type, FFT (keyword)
 def unique(
@@ -192,6 +201,7 @@ def unique(
     return_counts: L[True],
     axis: SupportsIndex | None = None,
     equal_nan: bool = True,
+    sorted: bool = True,
 ) -> tuple[NDArray[_ScalarT], _IntArray]: ...
 @overload  # unknown scalar-type, FFT (positional)
 def unique(
@@ -202,6 +212,7 @@ def unique(
     axis: SupportsIndex | None = None,
     *,
     equal_nan: bool = True,
+    sorted: bool = True,
 ) -> tuple[_AnyArray, _IntArray]: ...
 @overload  # unknown scalar-type, FFT (keyword)
 def unique(
@@ -212,6 +223,7 @@ def unique(
     return_counts: L[True],
     axis: SupportsIndex | None = None,
     equal_nan: bool = True,
+    sorted: bool = True,
 ) -> tuple[_AnyArray, _IntArray]: ...
 @overload  # known scalar-type, TTF
 def unique(
@@ -222,6 +234,7 @@ def unique(
     axis: SupportsIndex | None = None,
     *,
     equal_nan: bool = True,
+    sorted: bool = True,
 ) -> tuple[NDArray[_ScalarT], _IntArray, _IntArray]: ...
 @overload  # unknown scalar-type, TTF
 def unique(
@@ -232,6 +245,7 @@ def unique(
     axis: SupportsIndex | None = None,
     *,
     equal_nan: bool = True,
+    sorted: bool = True,
 ) -> tuple[_AnyArray, _IntArray, _IntArray]: ...
 @overload  # known scalar-type, TFT (positional)
 def unique(
@@ -242,6 +256,7 @@ def unique(
     axis: SupportsIndex | None = None,
     *,
     equal_nan: bool = True,
+    sorted: bool = True,
 ) -> tuple[NDArray[_ScalarT], _IntArray, _IntArray]: ...
 @overload  # known scalar-type, TFT (keyword)
 def unique(
@@ -252,6 +267,7 @@ def unique(
     return_counts: L[True],
     axis: SupportsIndex | None = None,
     equal_nan: bool = True,
+    sorted: bool = True,
 ) -> tuple[NDArray[_ScalarT], _IntArray, _IntArray]: ...
 @overload  # unknown scalar-type, TFT (positional)
 def unique(
@@ -262,6 +278,7 @@ def unique(
     axis: SupportsIndex | None = None,
     *,
     equal_nan: bool = True,
+    sorted: bool = True,
 ) -> tuple[_AnyArray, _IntArray, _IntArray]: ...
 @overload  # unknown scalar-type, TFT (keyword)
 def unique(
@@ -272,6 +289,7 @@ def unique(
     return_counts: L[True],
     axis: SupportsIndex | None = None,
     equal_nan: bool = True,
+    sorted: bool = True,
 ) -> tuple[_AnyArray, _IntArray, _IntArray]: ...
 @overload  # known scalar-type, FTT (positional)
 def unique(
@@ -282,6 +300,7 @@ def unique(
     axis: SupportsIndex | None = None,
     *,
     equal_nan: bool = True,
+    sorted: bool = True,
 ) -> tuple[NDArray[_ScalarT], _IntArray, _IntArray]: ...
 @overload  # known scalar-type, FTT (keyword)
 def unique(
@@ -292,6 +311,7 @@ def unique(
     return_counts: L[True],
     axis: SupportsIndex | None = None,
     equal_nan: bool = True,
+    sorted: bool = True,
 ) -> tuple[NDArray[_ScalarT], _IntArray, _IntArray]: ...
 @overload  # unknown scalar-type, FTT (positional)
 def unique(
@@ -302,6 +322,7 @@ def unique(
     axis: SupportsIndex | None = None,
     *,
     equal_nan: bool = True,
+    sorted: bool = True,
 ) -> tuple[_AnyArray, _IntArray, _IntArray]: ...
 @overload  # unknown scalar-type, FTT (keyword)
 def unique(
@@ -312,6 +333,7 @@ def unique(
     return_counts: L[True],
     axis: SupportsIndex | None = None,
     equal_nan: bool = True,
+    sorted: bool = True,
 ) -> tuple[_AnyArray, _IntArray, _IntArray]: ...
 @overload  # known scalar-type, TTT
 def unique(
@@ -322,6 +344,7 @@ def unique(
     axis: SupportsIndex | None = None,
     *,
     equal_nan: bool = True,
+    sorted: bool = True,
 ) -> tuple[NDArray[_ScalarT], _IntArray, _IntArray, _IntArray]: ...
 @overload  # unknown scalar-type, TTT
 def unique(
@@ -332,6 +355,7 @@ def unique(
     axis: SupportsIndex | None = None,
     *,
     equal_nan: bool = True,
+    sorted: bool = True,
 ) -> tuple[_AnyArray, _IntArray, _IntArray, _IntArray]: ...
 
 #

numpy/lib/_histograms_impl.pyi

@@ -35,16 +35,16 @@ def histogram_bin_edges(
 
 def histogram(
     a: ArrayLike,
-    bins: _BinKind | SupportsIndex | ArrayLike = ...,
-    range: tuple[float, float] | None = ...,
-    density: bool = ...,
-    weights: ArrayLike | None = ...,
+    bins: _BinKind | SupportsIndex | ArrayLike = 10,
+    range: tuple[float, float] | None = None,
+    density: bool | None = None,
+    weights: ArrayLike | None = None,
 ) -> tuple[NDArray[Any], NDArray[Any]]: ...
 
 def histogramdd(
     sample: ArrayLike,
-    bins: SupportsIndex | ArrayLike = ...,
-    range: Sequence[tuple[float, float]] = ...,
-    density: bool | None = ...,
-    weights: ArrayLike | None = ...,
+    bins: SupportsIndex | ArrayLike = 10,
+    range: Sequence[tuple[float, float]] | None = None,
+    density: bool | None = None,
+    weights: ArrayLike | None = None,
 ) -> tuple[NDArray[Any], tuple[NDArray[Any], ...]]: ...

numpy/lib/_index_tricks_impl.pyi

@@ -98,6 +98,8 @@ class ndindex:
     def ndincr(self, /) -> None: ...
 
 class nd_grid(Generic[_BoolT_co]):
+    __slots__ = ("sparse",)
+
     sparse: _BoolT_co
     def __init__(self, sparse: _BoolT_co = ...) -> None: ...
     @overload
@@ -107,10 +109,14 @@ class nd_grid(Generic[_BoolT_co]):
 
 @final
 class MGridClass(nd_grid[L[False]]):
+    __slots__ = ()
+
     def __init__(self) -> None: ...
 
 @final
 class OGridClass(nd_grid[L[True]]):
+    __slots__ = ()
+
     def __init__(self) -> None: ...
 
 class AxisConcatenator(Generic[_AxisT_co, _MatrixT_co, _NDMinT_co, _Trans1DT_co]):
@@ -147,13 +153,19 @@ class AxisConcatenator(Generic[_AxisT_co, _MatrixT_co, _NDMinT_co, _Trans1DT_co]
 
 @final
 class RClass(AxisConcatenator[L[0], L[False], L[1], L[-1]]):
+    __slots__ = ()
+
     def __init__(self, /) -> None: ...
 
 @final
 class CClass(AxisConcatenator[L[-1], L[False], L[2], L[0]]):
+    __slots__ = ()
+
     def __init__(self, /) -> None: ...
 
 class IndexExpression(Generic[_BoolT_co]):
+    __slots__ = ("maketuple",)
+
     maketuple: _BoolT_co
     def __init__(self, maketuple: _BoolT_co) -> None: ...
     @overload

numpy/lib/_polynomial_impl.pyi

@@ -137,20 +137,22 @@ def polyfit(
     x: _ArrayLikeFloat_co,
     y: _ArrayLikeFloat_co,
     deg: SupportsIndex | SupportsInt,
-    rcond: float | None = ...,
-    full: L[False] = ...,
-    w: _ArrayLikeFloat_co | None = ...,
-    cov: L[True, "unscaled"] = ...,
+    rcond: float | None = None,
+    full: L[False] = False,
+    w: _ArrayLikeFloat_co | None = None,
+    *,
+    cov: L[True, "unscaled"],
 ) -> _2Tup[NDArray[float64]]: ...
 @overload
 def polyfit(
     x: _ArrayLikeComplex_co,
     y: _ArrayLikeComplex_co,
     deg: SupportsIndex | SupportsInt,
-    rcond: float | None = ...,
-    full: L[False] = ...,
-    w: _ArrayLikeFloat_co | None = ...,
-    cov: L[True, "unscaled"] = ...,
+    rcond: float | None = None,
+    full: L[False] = False,
+    w: _ArrayLikeFloat_co | None = None,
+    *,
+    cov: L[True, "unscaled"],
 ) -> _2Tup[NDArray[complex128]]: ...
 @overload
 def polyfit(

numpy/lib/mixins.pyi

@@ -14,6 +14,8 @@ __all__ = ["NDArrayOperatorsMixin"]
 # As such, only little type safety can be provided here.
 
 class NDArrayOperatorsMixin(ABC):
+    __slots__ = ()
+
     @abstractmethod
     def __array_ufunc__(
         self,

numpy/lib/tests/test_index_tricks.py

@@ -199,6 +199,11 @@ class TestRavelUnravelIndex:
         with assert_raises(ValueError):
             np.unravel_index([1], (2, 1, 0))
 
+    def test_regression_size_1_index(self):
+        # actually tests the nditer size one index tracking
+        # regression test for gh-29690
+        np.unravel_index(np.array([[1, 0, 1, 0]], dtype=np.uint32), (4,))
+
 class TestGrid:
     def test_basic(self):
         a = mgrid[-1:1:10j]