numpy 2.3.3__cp314-cp314-win_arm64.whl → 2.3.4__cp314-cp314-win_arm64.whl

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Potentially problematic release.

This version of numpy might be problematic. Click here for more details.

Files changed (59) hide show
  1. numpy/__config__.py +6 -6
  2. numpy/__init__.pyi +819 -218
  3. numpy/_core/_multiarray_tests.cp314-win_arm64.pyd +0 -0
  4. numpy/_core/_multiarray_umath.cp314-win_arm64.pyd +0 -0
  5. numpy/_core/_operand_flag_tests.cp314-win_arm64.pyd +0 -0
  6. numpy/_core/_rational_tests.cp314-win_arm64.pyd +0 -0
  7. numpy/_core/_simd.cp314-win_arm64.pyd +0 -0
  8. numpy/_core/_struct_ufunc_tests.cp314-win_arm64.pyd +0 -0
  9. numpy/_core/_ufunc_config.py +2 -0
  10. numpy/_core/_ufunc_config.pyi +52 -6
  11. numpy/_core/_umath_tests.cp314-win_arm64.pyd +0 -0
  12. numpy/_core/lib/{libnpymath.a → npymath.lib} +0 -0
  13. numpy/_core/lib/pkgconfig/numpy.pc +1 -1
  14. numpy/_core/numerictypes.py +1 -1
  15. numpy/_core/tests/test_api.py +34 -1
  16. numpy/_core/tests/test_numerictypes.py +29 -0
  17. numpy/_core/tests/test_stringdtype.py +16 -16
  18. numpy/_core/tests/test_strings.py +15 -0
  19. numpy/_core/tests/test_umath.py +12 -0
  20. numpy/exceptions.pyi +2 -0
  21. numpy/fft/_pocketfft_umath.cp314-win_arm64.pyd +0 -0
  22. numpy/lib/_histograms_impl.pyi +8 -8
  23. numpy/lib/_index_tricks_impl.pyi +12 -0
  24. numpy/lib/_polynomial_impl.pyi +10 -8
  25. numpy/lib/mixins.pyi +2 -0
  26. numpy/lib/tests/test_index_tricks.py +5 -0
  27. numpy/linalg/_linalg.pyi +32 -39
  28. numpy/linalg/_umath_linalg.cp314-win_arm64.pyd +0 -0
  29. numpy/linalg/lapack_lite.cp314-win_arm64.pyd +0 -0
  30. numpy/ma/extras.pyi +4 -0
  31. numpy/random/_bounded_integers.cp314-win_arm64.pyd +0 -0
  32. numpy/random/_common.cp314-win_arm64.pyd +0 -0
  33. numpy/random/_generator.cp314-win_arm64.pyd +0 -0
  34. numpy/random/_mt19937.cp314-win_arm64.pyd +0 -0
  35. numpy/random/_pcg64.cp314-win_arm64.pyd +0 -0
  36. numpy/random/_philox.cp314-win_arm64.pyd +0 -0
  37. numpy/random/_sfc64.cp314-win_arm64.pyd +0 -0
  38. numpy/random/bit_generator.cp314-win_arm64.pyd +0 -0
  39. numpy/random/lib/{libnpyrandom.a → npyrandom.lib} +0 -0
  40. numpy/random/mtrand.cp314-win_arm64.pyd +0 -0
  41. numpy/random/tests/test_generator_mt19937.py +5 -0
  42. numpy/testing/_private/extbuild.pyi +3 -3
  43. numpy/testing/_private/utils.pyi +1 -1
  44. numpy/typing/tests/data/fail/bitwise_ops.pyi +3 -3
  45. numpy/typing/tests/data/fail/scalars.pyi +6 -6
  46. numpy/typing/tests/data/reveal/arithmetic.pyi +29 -29
  47. numpy/typing/tests/data/reveal/array_constructors.pyi +5 -5
  48. numpy/typing/tests/data/reveal/bitwise_ops.pyi +10 -11
  49. numpy/typing/tests/data/reveal/linalg.pyi +6 -6
  50. numpy/typing/tests/data/reveal/mod.pyi +18 -19
  51. numpy/version.py +2 -2
  52. numpy-2.3.4.dist-info/DELVEWHEEL +2 -0
  53. {numpy-2.3.3.dist-info → numpy-2.3.4.dist-info}/METADATA +1 -1
  54. {numpy-2.3.3.dist-info → numpy-2.3.4.dist-info}/RECORD +57 -58
  55. numpy/_typing/_callable.pyi +0 -279
  56. numpy-2.3.3.dist-info/DELVEWHEEL +0 -2
  57. {numpy-2.3.3.dist-info → numpy-2.3.4.dist-info}/LICENSE.txt +0 -0
  58. {numpy-2.3.3.dist-info → numpy-2.3.4.dist-info}/WHEEL +0 -0
  59. {numpy-2.3.3.dist-info → numpy-2.3.4.dist-info}/entry_points.txt +0 -0
numpy/typing/tests/data/fail/bitwise_ops.pyi CHANGED
@@ -9,9 +9,9 @@ i = int()
9
9
  f8 = np.float64()
10
10
 
11
11
  b_ >> f8 # type: ignore[operator]
12
- i8 << f8 # type: ignore[call-overload]
12
+ i8 << f8 # type: ignore[operator]
13
13
  i | f8 # type: ignore[operator]
14
- i8 ^ f8 # type: ignore[call-overload]
15
- u8 & f8 # type: ignore[call-overload]
14
+ i8 ^ f8 # type: ignore[operator]
15
+ u8 & f8 # type: ignore[operator]
16
16
  ~f8 # type: ignore[operator]
17
17
  # TODO: Certain mixes like i4 << u8 go to float and thus should fail
numpy/typing/tests/data/fail/scalars.pyi CHANGED
@@ -47,12 +47,12 @@ np.uint64(A()) # type: ignore[arg-type]
47
47
  np.void("test") # type: ignore[call-overload]
48
48
  np.void("test", dtype=None) # type: ignore[call-overload]
49
49
 
50
- np.generic(1) # type: ignore[abstract]
51
- np.number(1) # type: ignore[abstract]
52
- np.integer(1) # type: ignore[abstract]
53
- np.inexact(1) # type: ignore[abstract]
54
- np.character("test") # type: ignore[abstract]
55
- np.flexible(b"test") # type: ignore[abstract]
50
+ np.generic(1) # type: ignore[abstract, call-arg]
51
+ np.number(1) # type: ignore[abstract, call-arg]
52
+ np.integer(1) # type: ignore[abstract, call-arg]
53
+ np.inexact(1) # type: ignore[abstract, call-arg]
54
+ np.character("test") # type: ignore[abstract, call-arg]
55
+ np.flexible(b"test") # type: ignore[abstract, call-arg]
56
56
 
57
57
  np.float64(value=0.0) # type: ignore[call-arg]
58
58
  np.int64(value=0) # type: ignore[call-arg]
numpy/typing/tests/data/reveal/arithmetic.pyi CHANGED
@@ -3,7 +3,7 @@ from typing import Any, assert_type
3
3
 
4
4
  import numpy as np
5
5
  import numpy.typing as npt
6
- from numpy._typing import _32Bit, _64Bit, _128Bit
6
+ from numpy._typing import _64Bit, _128Bit
7
7
 
8
8
  b: bool
9
9
  c: complex
@@ -487,7 +487,7 @@ assert_type(c8 / b_, np.complex64)
487
487
 
488
488
  # Complex
489
489
 
490
- assert_type(c16 + f16, np.complex128 | np.complexfloating[_128Bit, _128Bit])
490
+ assert_type(c16 + f16, np.complexfloating)
491
491
  assert_type(c16 + c16, np.complex128)
492
492
  assert_type(c16 + f8, np.complex128)
493
493
  assert_type(c16 + i8, np.complex128)
@@ -500,12 +500,12 @@ assert_type(c16 + c, np.complex128)
500
500
  assert_type(c16 + f, np.complex128)
501
501
  assert_type(c16 + AR_f, npt.NDArray[np.complex128])
502
502
 
503
- assert_type(f16 + c16, np.complex128 | np.complexfloating[_128Bit, _128Bit])
503
+ assert_type(f16 + c16, np.complexfloating)
504
504
  assert_type(c16 + c16, np.complex128)
505
505
  assert_type(f8 + c16, np.complex128)
506
506
  assert_type(i8 + c16, np.complex128)
507
507
  assert_type(c8 + c16, np.complex128 | np.complex64)
508
- assert_type(f4 + c16, np.complex128 | np.complex64)
508
+ assert_type(f4 + c16, np.complexfloating)
509
509
  assert_type(i4 + c16, np.complex128)
510
510
  assert_type(b_ + c16, np.complex128)
511
511
  assert_type(b + c16, np.complex128)
@@ -513,10 +513,10 @@ assert_type(c + c16, np.complex128)
513
513
  assert_type(f + c16, np.complex128)
514
514
  assert_type(AR_f + c16, npt.NDArray[np.complex128])
515
515
 
516
- assert_type(c8 + f16, np.complexfloating[_32Bit, _32Bit] | np.complexfloating[_128Bit, _128Bit])
516
+ assert_type(c8 + f16, np.complex64 | np.complexfloating[_128Bit, _128Bit])
517
517
  assert_type(c8 + c16, np.complex64 | np.complex128)
518
518
  assert_type(c8 + f8, np.complex64 | np.complex128)
519
- assert_type(c8 + i8, np.complexfloating[_32Bit, _32Bit] | np.complexfloating[_64Bit, _64Bit])
519
+ assert_type(c8 + i8, np.complex64 | np.complexfloating[_64Bit, _64Bit])
520
520
  assert_type(c8 + c8, np.complex64)
521
521
  assert_type(c8 + f4, np.complex64)
522
522
  assert_type(c8 + i4, np.complex64)
@@ -541,7 +541,7 @@ assert_type(AR_f + c8, npt.NDArray[np.complexfloating])
541
541
 
542
542
  # Float
543
543
 
544
- assert_type(f8 + f16, np.float64 | np.floating[_128Bit])
544
+ assert_type(f8 + f16, np.floating)
545
545
  assert_type(f8 + f8, np.float64)
546
546
  assert_type(f8 + i8, np.float64)
547
547
  assert_type(f8 + f4, np.float64)
@@ -552,44 +552,44 @@ assert_type(f8 + c, np.float64 | np.complex128)
552
552
  assert_type(f8 + f, np.float64)
553
553
  assert_type(f8 + AR_f, npt.NDArray[np.float64])
554
554
 
555
- assert_type(f16 + f8, np.floating[_128Bit] | np.float64)
555
+ assert_type(f16 + f8, np.floating)
556
556
  assert_type(f8 + f8, np.float64)
557
557
  assert_type(i8 + f8, np.float64)
558
- assert_type(f4 + f8, np.float32 | np.float64)
559
- assert_type(i4 + f8,np.float64)
558
+ assert_type(f4 + f8, np.floating)
559
+ assert_type(i4 + f8, np.float64)
560
560
  assert_type(b_ + f8, np.float64)
561
561
  assert_type(b + f8, np.float64)
562
562
  assert_type(c + f8, np.complex128 | np.float64)
563
563
  assert_type(f + f8, np.float64)
564
564
  assert_type(AR_f + f8, npt.NDArray[np.float64])
565
565
 
566
- assert_type(f4 + f16, np.float32 | np.floating[_128Bit])
567
- assert_type(f4 + f8, np.float32 | np.float64)
568
- assert_type(f4 + i8, np.float32 | np.floating[_64Bit])
566
+ assert_type(f4 + f16, np.floating)
567
+ assert_type(f4 + f8, np.floating)
568
+ assert_type(f4 + i8, np.floating)
569
569
  assert_type(f4 + f4, np.float32)
570
- assert_type(f4 + i4, np.float32)
570
+ assert_type(f4 + i4, np.floating)
571
571
  assert_type(f4 + b_, np.float32)
572
572
  assert_type(f4 + b, np.float32)
573
- assert_type(f4 + c, np.complex64 | np.complex128)
574
- assert_type(f4 + f, np.float32 | np.float64)
573
+ assert_type(f4 + c, np.complexfloating)
574
+ assert_type(f4 + f, np.float32)
575
575
  assert_type(f4 + AR_f, npt.NDArray[np.float64])
576
576
 
577
- assert_type(f16 + f4, np.floating[_128Bit] | np.float32)
577
+ assert_type(f16 + f4, np.floating)
578
578
  assert_type(f8 + f4, np.float64)
579
- assert_type(i8 + f4, np.floating[_32Bit] | np.floating[_64Bit])
579
+ assert_type(i8 + f4, np.floating)
580
580
  assert_type(f4 + f4, np.float32)
581
- assert_type(i4 + f4, np.float32)
581
+ assert_type(i4 + f4, np.floating)
582
582
  assert_type(b_ + f4, np.float32)
583
583
  assert_type(b + f4, np.float32)
584
- assert_type(c + f4, np.complex64 | np.complex128)
585
- assert_type(f + f4, np.float64 | np.float32)
584
+ assert_type(c + f4, np.complexfloating)
585
+ assert_type(f + f4, np.float32)
586
586
  assert_type(AR_f + f4, npt.NDArray[np.float64])
587
587
 
588
588
  # Int
589
589
 
590
590
  assert_type(i8 + i8, np.int64)
591
591
  assert_type(i8 + u8, Any)
592
- assert_type(i8 + i4, np.signedinteger[_32Bit] | np.signedinteger[_64Bit])
592
+ assert_type(i8 + i4, np.signedinteger)
593
593
  assert_type(i8 + u4, Any)
594
594
  assert_type(i8 + b_, np.int64)
595
595
  assert_type(i8 + b, np.int64)
@@ -599,7 +599,7 @@ assert_type(i8 + AR_f, npt.NDArray[np.float64])
599
599
 
600
600
  assert_type(u8 + u8, np.uint64)
601
601
  assert_type(u8 + i4, Any)
602
- assert_type(u8 + u4, np.unsignedinteger[_32Bit] | np.unsignedinteger[_64Bit])
602
+ assert_type(u8 + u4, np.unsignedinteger)
603
603
  assert_type(u8 + b_, np.uint64)
604
604
  assert_type(u8 + b, np.uint64)
605
605
  assert_type(u8 + c, np.complex128)
@@ -608,7 +608,7 @@ assert_type(u8 + AR_f, npt.NDArray[np.float64])
608
608
 
609
609
  assert_type(i8 + i8, np.int64)
610
610
  assert_type(u8 + i8, Any)
611
- assert_type(i4 + i8, np.signedinteger[_32Bit] | np.signedinteger[_64Bit])
611
+ assert_type(i4 + i8, np.signedinteger)
612
612
  assert_type(u4 + i8, Any)
613
613
  assert_type(b_ + i8, np.int64)
614
614
  assert_type(b + i8, np.int64)
@@ -618,14 +618,14 @@ assert_type(AR_f + i8, npt.NDArray[np.float64])
618
618
 
619
619
  assert_type(u8 + u8, np.uint64)
620
620
  assert_type(i4 + u8, Any)
621
- assert_type(u4 + u8, np.unsignedinteger[_32Bit] | np.unsignedinteger[_64Bit])
621
+ assert_type(u4 + u8, np.unsignedinteger)
622
622
  assert_type(b_ + u8, np.uint64)
623
623
  assert_type(b + u8, np.uint64)
624
624
  assert_type(c + u8, np.complex128)
625
625
  assert_type(f + u8, np.float64)
626
626
  assert_type(AR_f + u8, npt.NDArray[np.float64])
627
627
 
628
- assert_type(i4 + i8, np.signedinteger[_32Bit] | np.signedinteger[_64Bit])
628
+ assert_type(i4 + i8, np.signedinteger)
629
629
  assert_type(i4 + i4, np.int32)
630
630
  assert_type(i4 + b_, np.int32)
631
631
  assert_type(i4 + b, np.int32)
@@ -633,13 +633,13 @@ assert_type(i4 + AR_f, npt.NDArray[np.float64])
633
633
 
634
634
  assert_type(u4 + i8, Any)
635
635
  assert_type(u4 + i4, Any)
636
- assert_type(u4 + u8, np.unsignedinteger[_32Bit] | np.unsignedinteger[_64Bit])
636
+ assert_type(u4 + u8, np.unsignedinteger)
637
637
  assert_type(u4 + u4, np.uint32)
638
638
  assert_type(u4 + b_, np.uint32)
639
639
  assert_type(u4 + b, np.uint32)
640
640
  assert_type(u4 + AR_f, npt.NDArray[np.float64])
641
641
 
642
- assert_type(i8 + i4, np.signedinteger[_32Bit] | np.signedinteger[_64Bit])
642
+ assert_type(i8 + i4, np.signedinteger)
643
643
  assert_type(i4 + i4, np.int32)
644
644
  assert_type(b_ + i4, np.int32)
645
645
  assert_type(b + i4, np.int32)
@@ -647,7 +647,7 @@ assert_type(AR_f + i4, npt.NDArray[np.float64])
647
647
 
648
648
  assert_type(i8 + u4, Any)
649
649
  assert_type(i4 + u4, Any)
650
- assert_type(u8 + u4, np.unsignedinteger[_32Bit] | np.unsignedinteger[_64Bit])
650
+ assert_type(u8 + u4, np.unsignedinteger)
651
651
  assert_type(u4 + u4, np.uint32)
652
652
  assert_type(b_ + u4, np.uint32)
653
653
  assert_type(b + u4, np.uint32)
numpy/typing/tests/data/reveal/array_constructors.pyi CHANGED
@@ -53,7 +53,7 @@ assert_type(np.empty([1, 5, 6], dtype='c16'), npt.NDArray[Any])
53
53
  assert_type(np.empty(mixed_shape), npt.NDArray[np.float64])
54
54
 
55
55
  assert_type(np.concatenate(A), npt.NDArray[np.float64])
56
- assert_type(np.concatenate([A, A]), Any) # pyright correctly infers this as NDArray[float64]
56
+ assert_type(np.concatenate([A, A]), npt.NDArray[Any]) # pyright correctly infers this as NDArray[float64]
57
57
  assert_type(np.concatenate([[1], A]), npt.NDArray[Any])
58
58
  assert_type(np.concatenate([[1], [1]]), npt.NDArray[Any])
59
59
  assert_type(np.concatenate((A, A)), npt.NDArray[np.float64])
@@ -222,19 +222,19 @@ assert_type(np.atleast_3d(A), npt.NDArray[np.float64])
222
222
  assert_type(np.atleast_3d(A, A), tuple[npt.NDArray[np.float64], npt.NDArray[np.float64]])
223
223
  assert_type(np.atleast_3d(A, A, A), tuple[npt.NDArray[np.float64], ...])
224
224
 
225
- assert_type(np.vstack([A, A]), np.ndarray[Any, Any]) # pyright correctly infers this as NDArray[float64]
225
+ assert_type(np.vstack([A, A]), npt.NDArray[np.float64])
226
226
  assert_type(np.vstack([A, A], dtype=np.float32), npt.NDArray[np.float32])
227
227
  assert_type(np.vstack([A, C]), npt.NDArray[Any])
228
228
  assert_type(np.vstack([C, C]), npt.NDArray[Any])
229
229
 
230
- assert_type(np.hstack([A, A]), np.ndarray[Any, Any]) # pyright correctly infers this as NDArray[float64]
230
+ assert_type(np.hstack([A, A]), npt.NDArray[np.float64])
231
231
  assert_type(np.hstack([A, A], dtype=np.float32), npt.NDArray[np.float32])
232
232
 
233
- assert_type(np.stack([A, A]), np.ndarray[Any, Any]) # pyright correctly infers this as NDArray[float64]
233
+ assert_type(np.stack([A, A]), npt.NDArray[np.float64])
234
234
  assert_type(np.stack([A, A], dtype=np.float32), npt.NDArray[np.float32])
235
235
  assert_type(np.stack([A, C]), npt.NDArray[Any])
236
236
  assert_type(np.stack([C, C]), npt.NDArray[Any])
237
- assert_type(np.stack([A, A], axis=0), np.ndarray[Any, Any]) # pyright correctly infers this as NDArray[float64]
237
+ assert_type(np.stack([A, A], axis=0), npt.NDArray[np.float64])
238
238
  assert_type(np.stack([A, A], out=B), SubClass[np.float64])
239
239
 
240
240
  assert_type(np.block([[A, A], [A, A]]), npt.NDArray[Any]) # pyright correctly infers this as NDArray[float64]
numpy/typing/tests/data/reveal/bitwise_ops.pyi CHANGED
@@ -3,7 +3,6 @@ from typing import Literal as L
3
3
 
4
4
  import numpy as np
5
5
  import numpy.typing as npt
6
- from numpy._typing import _32Bit, _64Bit
7
6
 
8
7
  FalseType: TypeAlias = L[False]
9
8
  TrueType: TypeAlias = L[True]
@@ -44,11 +43,11 @@ assert_type(i4 | i4, np.int32)
44
43
  assert_type(i4 ^ i4, np.int32)
45
44
  assert_type(i4 & i4, np.int32)
46
45
 
47
- assert_type(i8 << i4, np.signedinteger[_32Bit] | np.signedinteger[_64Bit])
48
- assert_type(i8 >> i4, np.signedinteger[_32Bit] | np.signedinteger[_64Bit])
49
- assert_type(i8 | i4, np.signedinteger[_32Bit] | np.signedinteger[_64Bit])
50
- assert_type(i8 ^ i4, np.signedinteger[_32Bit] | np.signedinteger[_64Bit])
51
- assert_type(i8 & i4, np.signedinteger[_32Bit] | np.signedinteger[_64Bit])
46
+ assert_type(i8 << i4, np.signedinteger)
47
+ assert_type(i8 >> i4, np.signedinteger)
48
+ assert_type(i8 | i4, np.signedinteger)
49
+ assert_type(i8 ^ i4, np.signedinteger)
50
+ assert_type(i8 & i4, np.signedinteger)
52
51
 
53
52
  assert_type(i8 << b_, np.int64)
54
53
  assert_type(i8 >> b_, np.int64)
@@ -86,11 +85,11 @@ assert_type(u4 | i4, np.signedinteger)
86
85
  assert_type(u4 ^ i4, np.signedinteger)
87
86
  assert_type(u4 & i4, np.signedinteger)
88
87
 
89
- assert_type(u4 << i, np.signedinteger)
90
- assert_type(u4 >> i, np.signedinteger)
91
- assert_type(u4 | i, np.signedinteger)
92
- assert_type(u4 ^ i, np.signedinteger)
93
- assert_type(u4 & i, np.signedinteger)
88
+ assert_type(u4 << i, np.uint32)
89
+ assert_type(u4 >> i, np.uint32)
90
+ assert_type(u4 | i, np.uint32)
91
+ assert_type(u4 ^ i, np.uint32)
92
+ assert_type(u4 & i, np.uint32)
94
93
 
95
94
  assert_type(u8 << b_, np.uint64)
96
95
  assert_type(u8 >> b_, np.uint64)
numpy/typing/tests/data/reveal/linalg.pyi CHANGED
@@ -43,9 +43,9 @@ assert_type(np.linalg.cholesky(AR_i8), npt.NDArray[np.float64])
43
43
  assert_type(np.linalg.cholesky(AR_f8), npt.NDArray[np.floating])
44
44
  assert_type(np.linalg.cholesky(AR_c16), npt.NDArray[np.complexfloating])
45
45
 
46
- assert_type(np.linalg.outer(AR_i8, AR_i8), npt.NDArray[np.signedinteger])
47
- assert_type(np.linalg.outer(AR_f8, AR_f8), npt.NDArray[np.floating])
48
- assert_type(np.linalg.outer(AR_c16, AR_c16), npt.NDArray[np.complexfloating])
46
+ assert_type(np.linalg.outer(AR_i8, AR_i8), npt.NDArray[np.int64])
47
+ assert_type(np.linalg.outer(AR_f8, AR_f8), npt.NDArray[np.float64])
48
+ assert_type(np.linalg.outer(AR_c16, AR_c16), npt.NDArray[np.complex128])
49
49
  assert_type(np.linalg.outer(AR_b, AR_b), npt.NDArray[np.bool])
50
50
  assert_type(np.linalg.outer(AR_O, AR_O), npt.NDArray[np.object_])
51
51
  assert_type(np.linalg.outer(AR_i8, AR_m), npt.NDArray[np.timedelta64])
@@ -127,6 +127,6 @@ assert_type(np.linalg.cross(AR_i8, AR_i8), npt.NDArray[np.signedinteger])
127
127
  assert_type(np.linalg.cross(AR_f8, AR_f8), npt.NDArray[np.floating])
128
128
  assert_type(np.linalg.cross(AR_c16, AR_c16), npt.NDArray[np.complexfloating])
129
129
 
130
- assert_type(np.linalg.matmul(AR_i8, AR_i8), npt.NDArray[np.signedinteger])
131
- assert_type(np.linalg.matmul(AR_f8, AR_f8), npt.NDArray[np.floating])
132
- assert_type(np.linalg.matmul(AR_c16, AR_c16), npt.NDArray[np.complexfloating])
130
+ assert_type(np.linalg.matmul(AR_i8, AR_i8), npt.NDArray[np.int64])
131
+ assert_type(np.linalg.matmul(AR_f8, AR_f8), npt.NDArray[np.float64])
132
+ assert_type(np.linalg.matmul(AR_c16, AR_c16), npt.NDArray[np.complex128])
numpy/typing/tests/data/reveal/mod.pyi CHANGED
@@ -4,7 +4,6 @@ from typing import assert_type
4
4
 
5
5
  import numpy as np
6
6
  import numpy.typing as npt
7
- from numpy._typing import _64Bit
8
7
 
9
8
  f8: np.float64
10
9
  i8: np.int64
@@ -109,51 +108,51 @@ assert_type(divmod(AR_b, b_), tuple[npt.NDArray[np.int8], npt.NDArray[np.int8]])
109
108
 
110
109
  assert_type(i8 % b, np.int64)
111
110
  assert_type(i8 % i8, np.int64)
112
- assert_type(i8 % f, np.float64 | np.floating[_64Bit])
113
- assert_type(i8 % f8, np.float64 | np.floating[_64Bit])
114
- assert_type(i4 % i8, np.int64 | np.int32)
115
- assert_type(i4 % f8, np.float64 | np.float32)
111
+ assert_type(i8 % f, np.float64)
112
+ assert_type(i8 % f8, np.float64)
113
+ assert_type(i4 % i8, np.signedinteger)
114
+ assert_type(i4 % f8, np.float64)
116
115
  assert_type(i4 % i4, np.int32)
117
- assert_type(i4 % f4, np.float32)
116
+ assert_type(i4 % f4, np.floating)
118
117
  assert_type(i8 % AR_b, npt.NDArray[np.int64])
119
118
 
120
119
  assert_type(divmod(i8, b), tuple[np.int64, np.int64])
121
- assert_type(divmod(i8, i4), tuple[np.int64, np.int64] | tuple[np.int32, np.int32])
120
+ assert_type(divmod(i8, i4), tuple[np.signedinteger, np.signedinteger])
122
121
  assert_type(divmod(i8, i8), tuple[np.int64, np.int64])
123
122
  # workarounds for https://github.com/microsoft/pyright/issues/9663
124
- assert_type(i8.__divmod__(f), tuple[np.floating[_64Bit], np.floating[_64Bit]] | tuple[np.float64, np.float64])
125
- assert_type(i8.__divmod__(f8), tuple[np.floating[_64Bit], np.floating[_64Bit]] | tuple[np.float64, np.float64])
126
- assert_type(divmod(i8, f4), tuple[np.floating[_64Bit], np.floating[_64Bit]] | tuple[np.float32, np.float32])
123
+ assert_type(i8.__divmod__(f), tuple[np.float64, np.float64])
124
+ assert_type(i8.__divmod__(f8), tuple[np.float64, np.float64])
125
+ assert_type(divmod(i8, f4), tuple[np.floating, np.floating])
127
126
  assert_type(divmod(i4, i4), tuple[np.int32, np.int32])
128
- assert_type(divmod(i4, f4), tuple[np.float32, np.float32])
127
+ assert_type(divmod(i4, f4), tuple[np.floating, np.floating])
129
128
  assert_type(divmod(i8, AR_b), tuple[npt.NDArray[np.int64], npt.NDArray[np.int64]])
130
129
 
131
130
  assert_type(b % i8, np.int64)
132
- assert_type(f % i8, np.float64 | np.floating[_64Bit])
131
+ assert_type(f % i8, np.float64)
133
132
  assert_type(i8 % i8, np.int64)
134
133
  assert_type(f8 % i8, np.float64)
135
- assert_type(i8 % i4, np.int64 | np.int32)
134
+ assert_type(i8 % i4, np.signedinteger)
136
135
  assert_type(f8 % i4, np.float64)
137
136
  assert_type(i4 % i4, np.int32)
138
- assert_type(f4 % i4, np.float32)
137
+ assert_type(f4 % i4, np.floating)
139
138
  assert_type(AR_b % i8, npt.NDArray[np.int64])
140
139
 
141
140
  assert_type(divmod(b, i8), tuple[np.int64, np.int64])
142
- assert_type(divmod(f, i8), tuple[np.floating[_64Bit], np.floating[_64Bit]] | tuple[np.float64, np.float64])
141
+ assert_type(divmod(f, i8), tuple[np.float64, np.float64])
143
142
  assert_type(divmod(i8, i8), tuple[np.int64, np.int64])
144
143
  assert_type(divmod(f8, i8), tuple[np.float64, np.float64])
145
- assert_type(divmod(i4, i8), tuple[np.int64, np.int64] | tuple[np.int32, np.int32])
144
+ assert_type(divmod(i4, i8), tuple[np.signedinteger, np.signedinteger])
146
145
  assert_type(divmod(i4, i4), tuple[np.int32, np.int32])
147
146
  # workarounds for https://github.com/microsoft/pyright/issues/9663
148
- assert_type(f4.__divmod__(i8), tuple[np.floating[_64Bit], np.floating[_64Bit]] | tuple[np.float32, np.float32])
149
- assert_type(f4.__divmod__(i4), tuple[np.float32, np.float32])
147
+ assert_type(f4.__divmod__(i8), tuple[np.floating, np.floating])
148
+ assert_type(f4.__divmod__(i4), tuple[np.floating, np.floating])
150
149
  assert_type(AR_b.__divmod__(i8), tuple[npt.NDArray[np.int64], npt.NDArray[np.int64]])
151
150
 
152
151
  # float
153
152
 
154
153
  assert_type(f8 % b, np.float64)
155
154
  assert_type(f8 % f, np.float64)
156
- assert_type(i8 % f4, np.floating[_64Bit] | np.float32)
155
+ assert_type(i8 % f4, np.floating)
157
156
  assert_type(f4 % f4, np.float32)
158
157
  assert_type(f8 % AR_b, npt.NDArray[np.float64])
159
158
 
numpy/version.py CHANGED
@@ -2,10 +2,10 @@
2
2
  """
3
3
  Module to expose more detailed version info for the installed `numpy`
4
4
  """
5
- version = "2.3.3"
5
+ version = "2.3.4"
6
6
  __version__ = version
7
7
  full_version = version
8
8
 
9
- git_revision = "f2a77a76e08719556527e0819182073fe9b5f1c3"
9
+ git_revision = "1458b9e79d1a5755eae9adcb346758f449b6b430"
10
10
  release = 'dev' not in version and '+' not in version
11
11
  short_version = version.split("+")[0]
numpy-2.3.4.dist-info/DELVEWHEEL ADDED
@@ -0,0 +1,2 @@
1
+ Version: 1.11.1
2
+ Arguments: ['C:\\Users\\runneradmin\\AppData\\Local\\Temp\\cibw-run-mi_ov32e\\cp314-win_arm64\\build\\venv\\Scripts\\delvewheel', 'repair', '--add-path', 'C:/a/numpy-release/numpy-release/.openblas/lib', '-w', 'C:\\Users\\runneradmin\\AppData\\Local\\Temp\\cibw-run-mi_ov32e\\cp314-win_arm64\\repaired_wheel', 'C:\\Users\\runneradmin\\AppData\\Local\\Temp\\cibw-run-mi_ov32e\\cp314-win_arm64\\built_wheel\\numpy-2.3.4-cp314-cp314-win_arm64.whl']
{numpy-2.3.3.dist-info → numpy-2.3.4.dist-info}/METADATA RENAMED
@@ -1,6 +1,6 @@
1
1
  Metadata-Version: 2.1
2
2
  Name: numpy
3
- Version: 2.3.3
3
+ Version: 2.3.4
4
4
  Summary: Fundamental package for array computing in Python
5
5
  Author: Travis E. Oliphant et al.
6
6
  Maintainer-Email: NumPy Developers <numpy-discussion@python.org>