Merge pull request #519 from numpy/farewell-nbitbase

Author: jorenham

src/_numtype/__init__.pyi

@@ -37,6 +37,7 @@ from ._dtype import (
     ToDTypeUInt32 as ToDTypeUInt32,
     ToDTypeUInt64 as ToDTypeUInt64,
     ToDTypeVoid as ToDTypeVoid,
+    _ToDType as _ToDType,
 )
 from ._just import (
     Just as Just,
@@ -578,17 +579,17 @@ ToNumber_2nd = TypeAliasType("ToNumber_2nd", _ToArray2_2nd[np.number, _PyNumber]
 ToNumber_3nd = TypeAliasType("ToNumber_3nd", _ToArray2_3nd[np.number, _PyNumber])
 
 # integers and real floats
-ToReal_nd = TypeAliasType("ToReal_nd", _ToArray2_nd[np.number[Any, float], _PyReal])
-ToReal_0d = TypeAliasType("ToReal_0d", _ToArray2_0d[np.number[Any, float], _PyReal])
-ToReal_1d = TypeAliasType("ToReal_1d", _ToArray2_1d[np.number[Any, float], _PyReal])
-ToReal_2d = TypeAliasType("ToReal_2d", _ToArray2_2d[np.number[Any, float], _PyReal])
-ToReal_3d = TypeAliasType("ToReal_3d", _ToArray2_3d[np.number[Any, float], _PyReal])
-ToReal_1ds = TypeAliasType("ToReal_1ds", _ToArray2_1ds[np.number[Any, float], _PyReal])
-ToReal_2ds = TypeAliasType("ToReal_2ds", _ToArray2_2ds[np.number[Any, float], _PyReal])
-ToReal_3ds = TypeAliasType("ToReal_3ds", _ToArray2_3ds[np.number[Any, float], _PyReal])
-ToReal_1nd = TypeAliasType("ToReal_1nd", _ToArray2_1nd[np.number[Any, float], _PyReal])
-ToReal_2nd = TypeAliasType("ToReal_2nd", _ToArray2_2nd[np.number[Any, float], _PyReal])
-ToReal_3nd = TypeAliasType("ToReal_3nd", _ToArray2_3nd[np.number[Any, float], _PyReal])
+ToReal_nd = TypeAliasType("ToReal_nd", _ToArray2_nd[np.number[float], _PyReal])
+ToReal_0d = TypeAliasType("ToReal_0d", _ToArray2_0d[np.number[float], _PyReal])
+ToReal_1d = TypeAliasType("ToReal_1d", _ToArray2_1d[np.number[float], _PyReal])
+ToReal_2d = TypeAliasType("ToReal_2d", _ToArray2_2d[np.number[float], _PyReal])
+ToReal_3d = TypeAliasType("ToReal_3d", _ToArray2_3d[np.number[float], _PyReal])
+ToReal_1ds = TypeAliasType("ToReal_1ds", _ToArray2_1ds[np.number[float], _PyReal])
+ToReal_2ds = TypeAliasType("ToReal_2ds", _ToArray2_2ds[np.number[float], _PyReal])
+ToReal_3ds = TypeAliasType("ToReal_3ds", _ToArray2_3ds[np.number[float], _PyReal])
+ToReal_1nd = TypeAliasType("ToReal_1nd", _ToArray2_1nd[np.number[float], _PyReal])
+ToReal_2nd = TypeAliasType("ToReal_2nd", _ToArray2_2nd[np.number[float], _PyReal])
+ToReal_3nd = TypeAliasType("ToReal_3nd", _ToArray2_3nd[np.number[float], _PyReal])
 
 # real- and complex floats
 ToInexact_nd = TypeAliasType("ToInexact_nd", _ToArray2_nd[np.inexact, _PyInexact])

src/_numtype/_scalar_co.pyi

@@ -1,4 +1,4 @@
-from typing import Any, TypeAlias
+from typing import TypeAlias
 
 import numpy as np
 
@@ -41,28 +41,28 @@ co_int8: TypeAlias = np.int8 | np.bool
 co_int16: TypeAlias = np.int16 | co_integer8
 co_int32: TypeAlias = np.int32 | co_integer16
 co_long: TypeAlias = np.long | co_int32
-co_int64: TypeAlias = np.signedinteger[Any] | co_integer32
+co_int64: TypeAlias = np.signedinteger | co_integer32
 
 co_uint8: TypeAlias = np.uint8 | np.bool
 co_uint16: TypeAlias = np.uint16 | co_uint8
 co_uint32: TypeAlias = np.uint32 | co_uint16
 co_ulong: TypeAlias = np.ulong | co_uint32
-co_uint64: TypeAlias = np.unsignedinteger[Any] | np.bool
+co_uint64: TypeAlias = np.unsignedinteger | np.bool
 
 co_integer8: TypeAlias = integer8 | np.bool
 co_integer16: TypeAlias = integer16 | co_integer8
 co_integer32: TypeAlias = integer32 | co_integer16
-co_integer64: TypeAlias = np.integer[Any] | np.bool
+co_integer64: TypeAlias = np.integer | np.bool
 co_integer = co_integer64
 
 co_float16: TypeAlias = np.float16 | co_integer8
 co_float32: TypeAlias = np.float32 | np.float16 | co_integer16
 co_float64: TypeAlias = np.float64 | np.float32 | np.float16 | co_integer64
-co_float: TypeAlias = np.floating[Any] | co_integer
+co_float: TypeAlias = np.floating | co_integer
 
 co_complex64: TypeAlias = inexact32 | number16 | integer8
 co_complex128: TypeAlias = number64 | number32 | number16 | co_integer
-co_complex: TypeAlias = np.number[Any] | np.bool
+co_complex: TypeAlias = np.number | np.bool
 co_number = co_complex
 
 co_timedelta: TypeAlias = np.timedelta64 | co_integer

src/numpy-stubs/@test/static/accept/ndarray_conversion.pyi

@@ -10,7 +10,6 @@ i4_2d: np.ndarray[tuple[int, int], np.dtype[np.int32]]
 f8_3d: np.ndarray[tuple[int, int, int], np.dtype[np.float64]]
 cG_4d: np.ndarray[tuple[int, int, int, int], np.dtype[np.clongdouble]]
 i0_nd: npt.NDArray[np.int_]
-uncertain_dtype: np.int32 | np.float64 | np.str_
 
 # item
 assert_type(i0_nd.item(), int)
@@ -54,11 +53,6 @@ assert_type(i4_2d.astype(np.uint16), np.ndarray[tuple[int, int], np.dtype[np.uin
 assert_type(np.astype(i4_2d, np.uint16), np.ndarray[tuple[int, int], np.dtype[np.uint16]])
 assert_type(f8_3d.astype(np.int16), np.ndarray[tuple[int, int, int], np.dtype[np.int16]])
 assert_type(np.astype(f8_3d, np.int16), np.ndarray[tuple[int, int, int], np.dtype[np.int16]])
-assert_type(
-    i4_2d.astype(uncertain_dtype),  # pyright: ignore[reportAssertTypeFailure]  # ndarray[(int, int), np.dtype]
-    np.ndarray[tuple[int, int], np.dtype[np.generic]],
-)
-assert_type(np.astype(i4_2d, uncertain_dtype), np.ndarray[tuple[int, int], np.dtype])
 
 # byteswap
 assert_type(i0_nd.byteswap(), npt.NDArray[np.int_])

src/numpy-stubs/__init__.pyi

@@ -351,7 +351,6 @@ from ._pytesttester import PytestTester
 from ._typing import (
     ArrayLike,
     DTypeLike,
-    NBitBase,
     NDArray,
     _ArrayLikeDT64_co,
     _ArrayLikeObject_co,
@@ -363,7 +362,6 @@ from ._typing import (
     _ScalarLike_co,
     _ShapeLike,
     _TD64Like_co,
-    _nbit_base as _n,
 )
 from ._typing._char_codes import _LongCodes, _ULongCodes
 from .lib import scimath as emath
@@ -661,10 +659,6 @@ _NumericT = TypeVar("_NumericT", bound=number | timedelta64)
 _CoNumberT = TypeVar("_CoNumberT", bound=bool_ | number)
 _CharT = TypeVar("_CharT", bound=character)
 
-_BitT = TypeVar("_BitT", bound=NBitBase, default=Any)  # pyright: ignore[reportDeprecated]
-_BitT1 = TypeVar("_BitT1", bound=NBitBase, default=Any)  # pyright: ignore[reportDeprecated]
-_BitT2 = TypeVar("_BitT2", bound=NBitBase, default=_BitT1)  # pyright: ignore[reportDeprecated]
-
 _ItemT_co = TypeVar("_ItemT_co", default=Any, covariant=True)
 _BoolItemT_co = TypeVar("_BoolItemT_co", bound=py_bool, default=py_bool, covariant=True)
 _NumberItemT = TypeVar("_NumberItemT", bound=complex)
@@ -4380,11 +4374,7 @@ class bool_(generic[_BoolItemT_co], Generic[_BoolItemT_co]):
 
 bool = bool_
 
-class number(
-    _CmpOpMixin[_nt.CoComplex_0d, _nt.CoComplex_1nd],
-    generic[_NumberItemT_co],
-    Generic[_BitT, _NumberItemT_co],
-):
+class number(_CmpOpMixin[_nt.CoComplex_0d, _nt.CoComplex_1nd], generic[_NumberItemT_co], Generic[_NumberItemT_co]):
     @type_check_only
     def __nep50_builtin__(self, /) -> tuple[int, Self]: ...
     @final
@@ -4411,7 +4401,7 @@ class number(
     def __class_getitem__(cls, item: Any, /) -> GenericAlias: ...
 
     #
-    def __abs__(self, /) -> number[_BitT]: ...
+    def __abs__(self, /) -> number: ...
     def __neg__(self, /) -> Self: ...
     def __pos__(self, /) -> Self: ...
 
@@ -4525,7 +4515,7 @@ class number(
 # increases over time. Assuming that this *always* holds significantly reduces the
 # complexity of the `[u]intp` and `[u]long` type definitions.
 
-class integer(_IntegralMixin, _RoundMixin, number[_BitT, int]):
+class integer(_IntegralMixin, _RoundMixin, number[int]):
     @abc.abstractmethod
     @type_check_only
     def __nep50__(
@@ -4670,7 +4660,7 @@ class integer(_IntegralMixin, _RoundMixin, number[_BitT, int]):
     @overload
     def __ror__(self, x: _nt.CastsWithScalar[Self, _IntegralT], /) -> _IntegralT: ...
 
-class signedinteger(integer[_BitT]):
+class signedinteger(integer):
     @abc.abstractmethod
     @type_check_only
     @override
@@ -4691,7 +4681,7 @@ class signedinteger(integer[_BitT]):
     @type_check_only
     def __nep50_rule5__(self, other: _JustInteger | _JustUnsignedInteger, /) -> signedinteger | float64: ...
 
-class int8(_IntMixin[L[1]], signedinteger[_n._8]):
+class int8(_IntMixin[L[1]], signedinteger):
     @override
     @type_check_only
     def __nep50__(
@@ -4712,7 +4702,7 @@ class int8(_IntMixin[L[1]], signedinteger[_n._8]):
 
 byte = int8
 
-class int16(_IntMixin[L[2]], signedinteger[_n._16]):
+class int16(_IntMixin[L[2]], signedinteger):
     @override
     @type_check_only
     def __nep50__(
@@ -4733,7 +4723,7 @@ class int16(_IntMixin[L[2]], signedinteger[_n._16]):
 
 short = int16
 
-class int32(_IntMixin[L[4]], signedinteger[_n._32]):
+class int32(_IntMixin[L[4]], signedinteger):
     @override
     @type_check_only
     def __nep50__(
@@ -4757,7 +4747,7 @@ class int32(_IntMixin[L[4]], signedinteger[_n._32]):
 
 intc = int32
 
-class int64(_IntMixin[L[8]], signedinteger[_n._64]):
+class int64(_IntMixin[L[8]], signedinteger):
     @override
     @type_check_only
     def __nep50__(
@@ -4795,7 +4785,7 @@ longlong = int64
 intp = int64
 int_ = intp
 
-class unsignedinteger(integer[_BitT]):
+class unsignedinteger(integer):
     @abc.abstractmethod
     @type_check_only
     @override
@@ -4808,7 +4798,7 @@ class unsignedinteger(integer[_BitT]):
     @type_check_only
     def __nep50_rule3__(self, other: _JustUnsignedInteger, /) -> unsignedinteger: ...
 
-class uint8(_IntMixin[L[1]], unsignedinteger[_n._8]):
+class uint8(_IntMixin[L[1]], unsignedinteger):
     @override
     @type_check_only
     def __nep50__(
@@ -4833,7 +4823,7 @@ class uint8(_IntMixin[L[1]], unsignedinteger[_n._8]):
 
 ubyte = uint8
 
-class uint16(_IntMixin[L[2]], unsignedinteger[_n._16]):
+class uint16(_IntMixin[L[2]], unsignedinteger):
     @override
     @type_check_only
     def __nep50__(
@@ -4860,7 +4850,7 @@ class uint16(_IntMixin[L[2]], unsignedinteger[_n._16]):
 
 ushort = uint16
 
-class uint32(_IntMixin[L[4]], unsignedinteger[_n._32]):
+class uint32(_IntMixin[L[4]], unsignedinteger):
     @override
     @type_check_only
     def __nep50__(
@@ -4887,7 +4877,7 @@ class uint32(_IntMixin[L[4]], unsignedinteger[_n._32]):
 
 uintc = uint32
 
-class uint64(_IntMixin[L[8]], unsignedinteger[_n._64]):
+class uint64(_IntMixin[L[8]], unsignedinteger):
     @override
     @type_check_only
     def __nep50__(
@@ -4923,7 +4913,7 @@ ulonglong = uint64
 uintp = uint64
 uint = uintp
 
-class inexact(number[_BitT, _InexactItemT_co], Generic[_BitT, _InexactItemT_co]):
+class inexact(number[_InexactItemT_co], Generic[_InexactItemT_co]):
     @abc.abstractmethod
     @type_check_only
     def __nep50__(self, below: clongdouble, above: _nt.co_integer8, /) -> inexact: ...
@@ -4961,7 +4951,7 @@ class inexact(number[_BitT, _InexactItemT_co], Generic[_BitT, _InexactItemT_co])
     @overload
     def __rtruediv__(self: _nt.CastsWithComplex[_ComplexFloatingT], x: _nt.JustComplex, /) -> _ComplexFloatingT: ...  # pyright: ignore[reportIncompatibleMethodOverride]
 
-class floating(_RealMixin, _RoundMixin, inexact[_BitT, float]):
+class floating(_RealMixin, _RoundMixin, inexact[float]):
     @abc.abstractmethod
     @override
     @type_check_only
@@ -5009,7 +4999,7 @@ class floating(_RealMixin, _RoundMixin, inexact[_BitT, float]):
     @overload
     def __rdivmod__(self, x: _nt.CastsWithScalar[Self, _FloatingT], /) -> _2Tuple[_FloatingT]: ...
 
-class float16(_FloatMixin[L[2]], floating[_n._16]):
+class float16(_FloatMixin[L[2]], floating):
     @override
     @type_check_only
     def __nep50__(self, below: inexact, above: _nt.co_integer8, /) -> float16: ...
@@ -5030,7 +5020,7 @@ class float16(_FloatMixin[L[2]], floating[_n._16]):
 
 half = float16
 
-class float32(_FloatMixin[L[4]], floating[_n._32]):
+class float32(_FloatMixin[L[4]], floating):
     @override
     @type_check_only
     def __nep50__(self, below: _float32_min | complexfloating, above: float16 | _nt.co_integer16, /) -> float32: ...
@@ -5049,7 +5039,7 @@ class float32(_FloatMixin[L[4]], floating[_n._32]):
 
 single = float32
 
-class float64(_FloatMixin[L[8]], floating[_n._64], float):  # type: ignore[misc]
+class float64(_FloatMixin[L[8]], floating, float):  # type: ignore[misc]
     @override
     @type_check_only
     def __nep50__(self, below: _inexact64_min, above: _float32_max | _nt.co_integer, /) -> float64: ...
@@ -5085,7 +5075,7 @@ class float64(_FloatMixin[L[8]], floating[_n._64], float):  # type: ignore[misc]
 
 double = float64
 
-class longdouble(_FloatMixin[L[12, 16]], floating[_n._64L]):
+class longdouble(_FloatMixin[L[12, 16]], floating):
     @override
     @type_check_only
     def __nep50__(
@@ -5123,7 +5113,7 @@ class longdouble(_FloatMixin[L[12, 16]], floating[_n._64L]):
 float96 = longdouble
 float128 = longdouble
 
-class complexfloating(inexact[_BitT1, complex], Generic[_BitT1, _BitT2]):
+class complexfloating(inexact[complex]):
     @abc.abstractmethod
     @override
     @type_check_only
@@ -5172,7 +5162,7 @@ class complexfloating(inexact[_BitT1, complex], Generic[_BitT1, _BitT2]):
     )
     def __round__(self, /, ndigits: CanIndex | None = None) -> Self: ...
 
-class complex64(complexfloating[_n._32]):
+class complex64(complexfloating):
     @override
     @type_check_only
     def __nep50__(self, below: complexfloating, above: _float32_max | _nt.co_integer16, /) -> complex64: ...
@@ -5209,7 +5199,7 @@ class complex64(complexfloating[_n._32]):
 
 csingle = complex64
 
-class complex128(complexfloating[_n._64], complex):  # type: ignore[misc]
+class complex128(complexfloating, complex):  # type: ignore[misc]
     @override
     @type_check_only
     def __nep50__(self, below: _complex128_min, above: complex64 | _float64_max | _nt.co_integer, /) -> complex128: ...
@@ -5255,7 +5245,7 @@ class complex128(complexfloating[_n._64], complex):  # type: ignore[misc]
 
 cdouble = complex128
 
-class clongdouble(complexfloating[_n._64L]):
+class clongdouble(complexfloating):
     @override
     @type_check_only
     def __nep50__(self, below: clongdouble, above: _nt.co_number, /) -> clongdouble: ...