numpy 2.3.3__cp312-cp312-win_amd64.whl → 2.3.4__cp312-cp312-win_amd64.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.3
+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_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

@@ -1631,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}'),
@@ -1652,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/_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]

numpy/linalg/_linalg.pyi

@@ -28,6 +28,7 @@ from numpy import (
 )
 from numpy._core.fromnumeric import matrix_transpose
 from numpy._core.numeric import tensordot
+from numpy._globals import _NoValueType
 from numpy._typing import (
     ArrayLike,
     DTypeLike,
@@ -78,7 +79,7 @@ __all__ = [
     "vecdot",
 ]
 
-_ArrayT = TypeVar("_ArrayT", bound=NDArray[Any])
+_NumberT = TypeVar("_NumberT", bound=np.number)
 
 _ModeKind: TypeAlias = L["reduced", "complete", "r", "raw"]
 
@@ -182,33 +183,29 @@ def cholesky(a: _ArrayLikeFloat_co, /, *, upper: bool = False) -> NDArray[floati
 def cholesky(a: _ArrayLikeComplex_co, /, *, upper: bool = False) -> NDArray[complexfloating]: ...
 
 @overload
-def outer(x1: _ArrayLike[Never], x2: _ArrayLike[Never]) -> NDArray[Any]: ...
+def outer(x1: _ArrayLike[Never], x2: _ArrayLike[Never], /) -> NDArray[Any]: ...
 @overload
-def outer(x1: _ArrayLikeBool_co, x2: _ArrayLikeBool_co) -> NDArray[np.bool]: ...
+def outer(x1: _ArrayLikeBool_co, x2: _ArrayLikeBool_co, /) -> NDArray[np.bool]: ...
 @overload
-def outer(x1: _ArrayLikeUInt_co, x2: _ArrayLikeUInt_co) -> NDArray[unsignedinteger]: ...
+def outer(x1: _ArrayLike[_NumberT], x2: _ArrayLike[_NumberT], /) -> NDArray[_NumberT]: ...
 @overload
-def outer(x1: _ArrayLikeInt_co, x2: _ArrayLikeInt_co) -> NDArray[signedinteger]: ...
+def outer(x1: _ArrayLikeUInt_co, x2: _ArrayLikeUInt_co, /) -> NDArray[unsignedinteger]: ...
 @overload
-def outer(x1: _ArrayLikeFloat_co, x2: _ArrayLikeFloat_co) -> NDArray[floating]: ...
+def outer(x1: _ArrayLikeInt_co, x2: _ArrayLikeInt_co, /) -> NDArray[signedinteger]: ...
 @overload
-def outer(
-    x1: _ArrayLikeComplex_co,
-    x2: _ArrayLikeComplex_co,
-) -> NDArray[complexfloating]: ...
+def outer(x1: _ArrayLikeFloat_co, x2: _ArrayLikeFloat_co, /) -> NDArray[floating]: ...
 @overload
-def outer(
-    x1: _ArrayLikeTD64_co,
-    x2: _ArrayLikeTD64_co,
-    out: None = ...,
-) -> NDArray[timedelta64]: ...
+def outer(x1: _ArrayLikeComplex_co, x2: _ArrayLikeComplex_co, /) -> NDArray[complexfloating]: ...
+@overload
+def outer(x1: _ArrayLikeTD64_co, x2: _ArrayLikeTD64_co, /) -> NDArray[timedelta64]: ...
 @overload
-def outer(x1: _ArrayLikeObject_co, x2: _ArrayLikeObject_co) -> NDArray[object_]: ...
+def outer(x1: _ArrayLikeObject_co, x2: _ArrayLikeObject_co, /) -> NDArray[object_]: ...
 @overload
 def outer(
     x1: _ArrayLikeComplex_co | _ArrayLikeTD64_co | _ArrayLikeObject_co,
     x2: _ArrayLikeComplex_co | _ArrayLikeTD64_co | _ArrayLikeObject_co,
-) -> _ArrayT: ...
+    /,
+) -> NDArray[Any]: ...
 
 @overload
 def qr(a: _ArrayLikeInt_co, mode: _ModeKind = ...) -> QRResult: ...
@@ -308,20 +305,26 @@ def matrix_rank(
 @overload
 def pinv(
     a: _ArrayLikeInt_co,
-    rcond: _ArrayLikeFloat_co = ...,
-    hermitian: bool = ...,
+    rcond: _ArrayLikeFloat_co | None = None,
+    hermitian: bool = False,
+    *,
+    rtol: _ArrayLikeFloat_co | _NoValueType = ...,
 ) -> NDArray[float64]: ...
 @overload
 def pinv(
     a: _ArrayLikeFloat_co,
-    rcond: _ArrayLikeFloat_co = ...,
-    hermitian: bool = ...,
+    rcond: _ArrayLikeFloat_co | None = None,
+    hermitian: bool = False,
+    *,
+    rtol: _ArrayLikeFloat_co | _NoValueType = ...,
 ) -> NDArray[floating]: ...
 @overload
 def pinv(
     a: _ArrayLikeComplex_co,
-    rcond: _ArrayLikeFloat_co = ...,
-    hermitian: bool = ...,
+    rcond: _ArrayLikeFloat_co | None = None,
+    hermitian: bool = False,
+    *,
+    rtol: _ArrayLikeFloat_co | _NoValueType = ...,
 ) -> NDArray[complexfloating]: ...
 
 # TODO: Returns a 2-tuple of scalars for 2D arrays and
@@ -461,22 +464,12 @@ def cross(
 ) -> NDArray[complexfloating]: ...
 
 @overload
-def matmul(
-    x1: _ArrayLikeInt_co,
-    x2: _ArrayLikeInt_co,
-) -> NDArray[signedinteger]: ...
+def matmul(x1: _ArrayLike[_NumberT], x2: _ArrayLike[_NumberT], /) -> NDArray[_NumberT]: ...
 @overload
-def matmul(
-    x1: _ArrayLikeUInt_co,
-    x2: _ArrayLikeUInt_co,
-) -> NDArray[unsignedinteger]: ...
+def matmul(x1: _ArrayLikeInt_co, x2: _ArrayLikeInt_co, /) -> NDArray[signedinteger]: ...
 @overload
-def matmul(
-    x1: _ArrayLikeFloat_co,
-    x2: _ArrayLikeFloat_co,
-) -> NDArray[floating]: ...
+def matmul(x1: _ArrayLikeUInt_co, x2: _ArrayLikeUInt_co, /) -> NDArray[unsignedinteger]: ...
 @overload
-def matmul(
-    x1: _ArrayLikeComplex_co,
-    x2: _ArrayLikeComplex_co,
-) -> NDArray[complexfloating]: ...
+def matmul(x1: _ArrayLikeFloat_co, x2: _ArrayLikeFloat_co, /) -> NDArray[floating]: ...
+@overload
+def matmul(x1: _ArrayLikeComplex_co, x2: _ArrayLikeComplex_co, /) -> NDArray[complexfloating]: ...

numpy/ma/extras.pyi

@@ -110,12 +110,16 @@ def cov(x, y=..., rowvar=..., bias=..., allow_masked=..., ddof=...): ...
 def corrcoef(x, y=..., rowvar=..., bias=..., allow_masked=..., ddof=...): ...
 
 class MAxisConcatenator(AxisConcatenator):
+    __slots__ = ()
+
     @staticmethod
     def concatenate(arrays: Incomplete, axis: int = 0) -> Incomplete: ...  # type: ignore[override]  # pyright: ignore[reportIncompatibleMethodOverride]
     @classmethod
     def makemat(cls, arr: Incomplete) -> Incomplete: ...  # type: ignore[override]  # pyright: ignore[reportIncompatibleVariableOverride]
 
 class mr_class(MAxisConcatenator):
+    __slots__ = ()
+
     def __init__(self) -> None: ...
 
 mr_: mr_class