forked from numpy/numpy
-
Notifications
You must be signed in to change notification settings - Fork 0
/
__init__.pyi
4345 lines (3993 loc) · 144 KB
/
__init__.pyi
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
433
434
435
436
437
438
439
440
441
442
443
444
445
446
447
448
449
450
451
452
453
454
455
456
457
458
459
460
461
462
463
464
465
466
467
468
469
470
471
472
473
474
475
476
477
478
479
480
481
482
483
484
485
486
487
488
489
490
491
492
493
494
495
496
497
498
499
500
501
502
503
504
505
506
507
508
509
510
511
512
513
514
515
516
517
518
519
520
521
522
523
524
525
526
527
528
529
530
531
532
533
534
535
536
537
538
539
540
541
542
543
544
545
546
547
548
549
550
551
552
553
554
555
556
557
558
559
560
561
562
563
564
565
566
567
568
569
570
571
572
573
574
575
576
577
578
579
580
581
582
583
584
585
586
587
588
589
590
591
592
593
594
595
596
597
598
599
600
601
602
603
604
605
606
607
608
609
610
611
612
613
614
615
616
617
618
619
620
621
622
623
624
625
626
627
628
629
630
631
632
633
634
635
636
637
638
639
640
641
642
643
644
645
646
647
648
649
650
651
652
653
654
655
656
657
658
659
660
661
662
663
664
665
666
667
668
669
670
671
672
673
674
675
676
677
678
679
680
681
682
683
684
685
686
687
688
689
690
691
692
693
694
695
696
697
698
699
700
701
702
703
704
705
706
707
708
709
710
711
712
713
714
715
716
717
718
719
720
721
722
723
724
725
726
727
728
729
730
731
732
733
734
735
736
737
738
739
740
741
742
743
744
745
746
747
748
749
750
751
752
753
754
755
756
757
758
759
760
761
762
763
764
765
766
767
768
769
770
771
772
773
774
775
776
777
778
779
780
781
782
783
784
785
786
787
788
789
790
791
792
793
794
795
796
797
798
799
800
801
802
803
804
805
806
807
808
809
810
811
812
813
814
815
816
817
818
819
820
821
822
823
824
825
826
827
828
829
830
831
832
833
834
835
836
837
838
839
840
841
842
843
844
845
846
847
848
849
850
851
852
853
854
855
856
857
858
859
860
861
862
863
864
865
866
867
868
869
870
871
872
873
874
875
876
877
878
879
880
881
882
883
884
885
886
887
888
889
890
891
892
893
894
895
896
897
898
899
900
901
902
903
904
905
906
907
908
909
910
911
912
913
914
915
916
917
918
919
920
921
922
923
924
925
926
927
928
929
930
931
932
933
934
935
936
937
938
939
940
941
942
943
944
945
946
947
948
949
950
951
952
953
954
955
956
957
958
959
960
961
962
963
964
965
966
967
968
969
970
971
972
973
974
975
976
977
978
979
980
981
982
983
984
985
986
987
988
989
990
991
992
993
994
995
996
997
998
999
1000
import builtins
import os
import sys
import mmap
import ctypes as ct
import array as _array
import datetime as dt
import enum
from abc import abstractmethod
from types import TracebackType, MappingProxyType
from contextlib import ContextDecorator
if sys.version_info >= (3, 9):
from types import GenericAlias
from numpy._pytesttester import PytestTester
from numpy.core._internal import _ctypes
from numpy.typing import (
# Arrays
ArrayLike,
NDArray,
_SupportsArray,
_NestedSequence,
_FiniteNestedSequence,
_SupportsArray,
_ArrayLikeBool_co,
_ArrayLikeUInt_co,
_ArrayLikeInt_co,
_ArrayLikeFloat_co,
_ArrayLikeComplex_co,
_ArrayLikeNumber_co,
_ArrayLikeTD64_co,
_ArrayLikeDT64_co,
_ArrayLikeObject_co,
_ArrayLikeStr_co,
_ArrayLikeBytes_co,
# DTypes
DTypeLike,
_SupportsDType,
_VoidDTypeLike,
# Shapes
_Shape,
_ShapeLike,
# Scalars
_CharLike_co,
_BoolLike_co,
_IntLike_co,
_FloatLike_co,
_ComplexLike_co,
_TD64Like_co,
_NumberLike_co,
_ScalarLike_co,
# `number` precision
NBitBase,
_256Bit,
_128Bit,
_96Bit,
_80Bit,
_64Bit,
_32Bit,
_16Bit,
_8Bit,
_NBitByte,
_NBitShort,
_NBitIntC,
_NBitIntP,
_NBitInt,
_NBitLongLong,
_NBitHalf,
_NBitSingle,
_NBitDouble,
_NBitLongDouble,
# Character codes
_BoolCodes,
_UInt8Codes,
_UInt16Codes,
_UInt32Codes,
_UInt64Codes,
_Int8Codes,
_Int16Codes,
_Int32Codes,
_Int64Codes,
_Float16Codes,
_Float32Codes,
_Float64Codes,
_Complex64Codes,
_Complex128Codes,
_ByteCodes,
_ShortCodes,
_IntCCodes,
_IntPCodes,
_IntCodes,
_LongLongCodes,
_UByteCodes,
_UShortCodes,
_UIntCCodes,
_UIntPCodes,
_UIntCodes,
_ULongLongCodes,
_HalfCodes,
_SingleCodes,
_DoubleCodes,
_LongDoubleCodes,
_CSingleCodes,
_CDoubleCodes,
_CLongDoubleCodes,
_DT64Codes,
_TD64Codes,
_StrCodes,
_BytesCodes,
_VoidCodes,
_ObjectCodes,
# Ufuncs
_UFunc_Nin1_Nout1,
_UFunc_Nin2_Nout1,
_UFunc_Nin1_Nout2,
_UFunc_Nin2_Nout2,
_GUFunc_Nin2_Nout1,
)
from numpy.typing._callable import (
_BoolOp,
_BoolBitOp,
_BoolSub,
_BoolTrueDiv,
_BoolMod,
_BoolDivMod,
_TD64Div,
_IntTrueDiv,
_UnsignedIntOp,
_UnsignedIntBitOp,
_UnsignedIntMod,
_UnsignedIntDivMod,
_SignedIntOp,
_SignedIntBitOp,
_SignedIntMod,
_SignedIntDivMod,
_FloatOp,
_FloatMod,
_FloatDivMod,
_ComplexOp,
_NumberOp,
_ComparisonOp,
)
# NOTE: Numpy's mypy plugin is used for removing the types unavailable
# to the specific platform
from numpy.typing._extended_precision import (
uint128 as uint128,
uint256 as uint256,
int128 as int128,
int256 as int256,
float80 as float80,
float96 as float96,
float128 as float128,
float256 as float256,
complex160 as complex160,
complex192 as complex192,
complex256 as complex256,
complex512 as complex512,
)
from typing import (
Literal as L,
Any,
ByteString,
Callable,
Container,
Callable,
Dict,
Generic,
IO,
Iterable,
Iterator,
List,
Mapping,
NoReturn,
Optional,
overload,
Sequence,
Sized,
SupportsComplex,
SupportsFloat,
SupportsInt,
Text,
Tuple,
Type,
TypeVar,
Union,
Protocol,
SupportsIndex,
Final,
final,
ClassVar,
Set,
)
# Ensures that the stubs are picked up
from numpy import (
ctypeslib as ctypeslib,
fft as fft,
lib as lib,
linalg as linalg,
ma as ma,
matrixlib as matrixlib,
polynomial as polynomial,
random as random,
testing as testing,
version as version,
)
from numpy.core import defchararray, records
char = defchararray
rec = records
from numpy.core.function_base import (
linspace as linspace,
logspace as logspace,
geomspace as geomspace,
)
from numpy.core.fromnumeric import (
take as take,
reshape as reshape,
choose as choose,
repeat as repeat,
put as put,
swapaxes as swapaxes,
transpose as transpose,
partition as partition,
argpartition as argpartition,
sort as sort,
argsort as argsort,
argmax as argmax,
argmin as argmin,
searchsorted as searchsorted,
resize as resize,
squeeze as squeeze,
diagonal as diagonal,
trace as trace,
ravel as ravel,
nonzero as nonzero,
shape as shape,
compress as compress,
clip as clip,
sum as sum,
all as all,
any as any,
cumsum as cumsum,
ptp as ptp,
amax as amax,
amin as amin,
prod as prod,
cumprod as cumprod,
ndim as ndim,
size as size,
around as around,
mean as mean,
std as std,
var as var,
)
from numpy.core._asarray import (
require as require,
)
from numpy.core._type_aliases import (
sctypes as sctypes,
sctypeDict as sctypeDict,
)
from numpy.core._ufunc_config import (
seterr as seterr,
geterr as geterr,
setbufsize as setbufsize,
getbufsize as getbufsize,
seterrcall as seterrcall,
geterrcall as geterrcall,
_ErrKind,
_ErrFunc,
_ErrDictOptional,
)
from numpy.core.arrayprint import (
set_printoptions as set_printoptions,
get_printoptions as get_printoptions,
array2string as array2string,
format_float_scientific as format_float_scientific,
format_float_positional as format_float_positional,
array_repr as array_repr,
array_str as array_str,
set_string_function as set_string_function,
printoptions as printoptions,
)
from numpy.core.einsumfunc import (
einsum as einsum,
einsum_path as einsum_path,
)
from numpy.core.multiarray import (
ALLOW_THREADS as ALLOW_THREADS,
BUFSIZE as BUFSIZE,
CLIP as CLIP,
MAXDIMS as MAXDIMS,
MAY_SHARE_BOUNDS as MAY_SHARE_BOUNDS,
MAY_SHARE_EXACT as MAY_SHARE_EXACT,
RAISE as RAISE,
WRAP as WRAP,
tracemalloc_domain as tracemalloc_domain,
array as array,
empty_like as empty_like,
empty as empty,
zeros as zeros,
concatenate as concatenate,
inner as inner,
where as where,
lexsort as lexsort,
can_cast as can_cast,
min_scalar_type as min_scalar_type,
result_type as result_type,
dot as dot,
vdot as vdot,
bincount as bincount,
copyto as copyto,
putmask as putmask,
packbits as packbits,
unpackbits as unpackbits,
shares_memory as shares_memory,
may_share_memory as may_share_memory,
asarray as asarray,
asanyarray as asanyarray,
ascontiguousarray as ascontiguousarray,
asfortranarray as asfortranarray,
arange as arange,
busday_count as busday_count,
busday_offset as busday_offset,
compare_chararrays as compare_chararrays,
datetime_as_string as datetime_as_string,
datetime_data as datetime_data,
frombuffer as frombuffer,
fromfile as fromfile,
fromiter as fromiter,
is_busday as is_busday,
promote_types as promote_types,
seterrobj as seterrobj,
geterrobj as geterrobj,
fromstring as fromstring,
frompyfunc as frompyfunc,
nested_iters as nested_iters,
flagsobj,
)
from numpy.core.numeric import (
zeros_like as zeros_like,
ones as ones,
ones_like as ones_like,
full as full,
full_like as full_like,
count_nonzero as count_nonzero,
isfortran as isfortran,
argwhere as argwhere,
flatnonzero as flatnonzero,
correlate as correlate,
convolve as convolve,
outer as outer,
tensordot as tensordot,
roll as roll,
rollaxis as rollaxis,
moveaxis as moveaxis,
cross as cross,
indices as indices,
fromfunction as fromfunction,
isscalar as isscalar,
binary_repr as binary_repr,
base_repr as base_repr,
identity as identity,
allclose as allclose,
isclose as isclose,
array_equal as array_equal,
array_equiv as array_equiv,
)
from numpy.core.numerictypes import (
maximum_sctype as maximum_sctype,
issctype as issctype,
obj2sctype as obj2sctype,
issubclass_ as issubclass_,
issubsctype as issubsctype,
issubdtype as issubdtype,
sctype2char as sctype2char,
find_common_type as find_common_type,
nbytes as nbytes,
cast as cast,
ScalarType as ScalarType,
typecodes as typecodes,
)
from numpy.core.shape_base import (
atleast_1d as atleast_1d,
atleast_2d as atleast_2d,
atleast_3d as atleast_3d,
block as block,
hstack as hstack,
stack as stack,
vstack as vstack,
)
from numpy.lib import (
emath as emath,
)
from numpy.lib.arraypad import (
pad as pad,
)
from numpy.lib.arraysetops import (
ediff1d as ediff1d,
intersect1d as intersect1d,
setxor1d as setxor1d,
union1d as union1d,
setdiff1d as setdiff1d,
unique as unique,
in1d as in1d,
isin as isin,
)
from numpy.lib.arrayterator import (
Arrayterator as Arrayterator,
)
from numpy.lib.function_base import (
select as select,
piecewise as piecewise,
trim_zeros as trim_zeros,
copy as copy,
iterable as iterable,
percentile as percentile,
diff as diff,
gradient as gradient,
angle as angle,
unwrap as unwrap,
sort_complex as sort_complex,
disp as disp,
flip as flip,
rot90 as rot90,
extract as extract,
place as place,
asarray_chkfinite as asarray_chkfinite,
average as average,
bincount as bincount,
digitize as digitize,
cov as cov,
corrcoef as corrcoef,
msort as msort,
median as median,
sinc as sinc,
hamming as hamming,
hanning as hanning,
bartlett as bartlett,
blackman as blackman,
kaiser as kaiser,
trapz as trapz,
i0 as i0,
add_newdoc as add_newdoc,
add_docstring as add_docstring,
meshgrid as meshgrid,
delete as delete,
insert as insert,
append as append,
interp as interp,
add_newdoc_ufunc as add_newdoc_ufunc,
quantile as quantile,
)
from numpy.lib.histograms import (
histogram_bin_edges as histogram_bin_edges,
histogram as histogram,
histogramdd as histogramdd,
)
from numpy.lib.index_tricks import (
ravel_multi_index as ravel_multi_index,
unravel_index as unravel_index,
mgrid as mgrid,
ogrid as ogrid,
r_ as r_,
c_ as c_,
s_ as s_,
index_exp as index_exp,
ix_ as ix_,
fill_diagonal as fill_diagonal,
diag_indices as diag_indices,
diag_indices_from as diag_indices_from,
)
from numpy.lib.nanfunctions import (
nansum as nansum,
nanmax as nanmax,
nanmin as nanmin,
nanargmax as nanargmax,
nanargmin as nanargmin,
nanmean as nanmean,
nanmedian as nanmedian,
nanpercentile as nanpercentile,
nanvar as nanvar,
nanstd as nanstd,
nanprod as nanprod,
nancumsum as nancumsum,
nancumprod as nancumprod,
nanquantile as nanquantile,
)
from numpy.lib.npyio import (
savetxt as savetxt,
loadtxt as loadtxt,
genfromtxt as genfromtxt,
recfromtxt as recfromtxt,
recfromcsv as recfromcsv,
load as load,
save as save,
savez as savez,
savez_compressed as savez_compressed,
packbits as packbits,
unpackbits as unpackbits,
fromregex as fromregex,
)
from numpy.lib.polynomial import (
poly as poly,
roots as roots,
polyint as polyint,
polyder as polyder,
polyadd as polyadd,
polysub as polysub,
polymul as polymul,
polydiv as polydiv,
polyval as polyval,
polyfit as polyfit,
)
from numpy.lib.shape_base import (
column_stack as column_stack,
row_stack as row_stack,
dstack as dstack,
array_split as array_split,
split as split,
hsplit as hsplit,
vsplit as vsplit,
dsplit as dsplit,
apply_over_axes as apply_over_axes,
expand_dims as expand_dims,
apply_along_axis as apply_along_axis,
kron as kron,
tile as tile,
get_array_wrap as get_array_wrap,
take_along_axis as take_along_axis,
put_along_axis as put_along_axis,
)
from numpy.lib.stride_tricks import (
broadcast_to as broadcast_to,
broadcast_arrays as broadcast_arrays,
broadcast_shapes as broadcast_shapes,
)
from numpy.lib.twodim_base import (
diag as diag,
diagflat as diagflat,
eye as eye,
fliplr as fliplr,
flipud as flipud,
tri as tri,
triu as triu,
tril as tril,
vander as vander,
histogram2d as histogram2d,
mask_indices as mask_indices,
tril_indices as tril_indices,
tril_indices_from as tril_indices_from,
triu_indices as triu_indices,
triu_indices_from as triu_indices_from,
)
from numpy.lib.type_check import (
mintypecode as mintypecode,
asfarray as asfarray,
real as real,
imag as imag,
iscomplex as iscomplex,
isreal as isreal,
iscomplexobj as iscomplexobj,
isrealobj as isrealobj,
nan_to_num as nan_to_num,
real_if_close as real_if_close,
typename as typename,
common_type as common_type,
)
from numpy.lib.ufunclike import (
fix as fix,
isposinf as isposinf,
isneginf as isneginf,
)
from numpy.lib.utils import (
issubclass_ as issubclass_,
issubsctype as issubsctype,
issubdtype as issubdtype,
deprecate as deprecate,
deprecate_with_doc as deprecate_with_doc,
get_include as get_include,
info as info,
source as source,
who as who,
lookfor as lookfor,
byte_bounds as byte_bounds,
safe_eval as safe_eval,
)
from numpy.matrixlib import (
asmatrix as asmatrix,
mat as mat,
bmat as bmat,
)
_AnyStr_contra = TypeVar("_AnyStr_contra", str, bytes, contravariant=True)
# Protocol for representing file-like-objects accepted
# by `ndarray.tofile` and `fromfile`
class _IOProtocol(Protocol):
def flush(self) -> object: ...
def fileno(self) -> int: ...
def tell(self) -> SupportsIndex: ...
def seek(self, offset: int, whence: int, /) -> object: ...
# NOTE: `seek`, `write` and `flush` are technically only required
# for `readwrite`/`write` modes
class _MemMapIOProtocol(Protocol):
def flush(self) -> object: ...
def fileno(self) -> SupportsIndex: ...
def tell(self) -> int: ...
def seek(self, offset: int, whence: int, /) -> object: ...
def write(self, s: bytes, /) -> object: ...
@property
def read(self) -> object: ...
class _SupportsWrite(Protocol[_AnyStr_contra]):
def write(self, s: _AnyStr_contra, /) -> object: ...
__all__: List[str]
__path__: List[str]
__version__: str
__git_version__: str
test: PytestTester
# TODO: Move placeholders to their respective module once
# their annotations are properly implemented
#
# Placeholders for classes
# Some of these are aliases; others are wrappers with an identical signature
round = around
round_ = around
max = amax
min = amin
product = prod
cumproduct = cumprod
sometrue = any
alltrue = all
def show_config() -> None: ...
_NdArraySubClass = TypeVar("_NdArraySubClass", bound=ndarray)
_DTypeScalar_co = TypeVar("_DTypeScalar_co", covariant=True, bound=generic)
_ByteOrder = L["S", "<", ">", "=", "|", "L", "B", "N", "I"]
class dtype(Generic[_DTypeScalar_co]):
names: None | Tuple[builtins.str, ...]
# Overload for subclass of generic
@overload
def __new__(
cls,
dtype: Type[_DTypeScalar_co],
align: bool = ...,
copy: bool = ...,
) -> dtype[_DTypeScalar_co]: ...
# Overloads for string aliases, Python types, and some assorted
# other special cases. Order is sometimes important because of the
# subtype relationships
#
# bool < int < float < complex < object
#
# so we have to make sure the overloads for the narrowest type is
# first.
# Builtin types
@overload
def __new__(cls, dtype: Type[bool], align: bool = ..., copy: bool = ...) -> dtype[bool_]: ...
@overload
def __new__(cls, dtype: Type[int], align: bool = ..., copy: bool = ...) -> dtype[int_]: ...
@overload
def __new__(cls, dtype: None | Type[float], align: bool = ..., copy: bool = ...) -> dtype[float_]: ...
@overload
def __new__(cls, dtype: Type[complex], align: bool = ..., copy: bool = ...) -> dtype[complex_]: ...
@overload
def __new__(cls, dtype: Type[builtins.str], align: bool = ..., copy: bool = ...) -> dtype[str_]: ...
@overload
def __new__(cls, dtype: Type[bytes], align: bool = ..., copy: bool = ...) -> dtype[bytes_]: ...
# `unsignedinteger` string-based representations and ctypes
@overload
def __new__(cls, dtype: _UInt8Codes | Type[ct.c_uint8], align: bool = ..., copy: bool = ...) -> dtype[uint8]: ...
@overload
def __new__(cls, dtype: _UInt16Codes | Type[ct.c_uint16], align: bool = ..., copy: bool = ...) -> dtype[uint16]: ...
@overload
def __new__(cls, dtype: _UInt32Codes | Type[ct.c_uint32], align: bool = ..., copy: bool = ...) -> dtype[uint32]: ...
@overload
def __new__(cls, dtype: _UInt64Codes | Type[ct.c_uint64], align: bool = ..., copy: bool = ...) -> dtype[uint64]: ...
@overload
def __new__(cls, dtype: _UByteCodes | Type[ct.c_ubyte], align: bool = ..., copy: bool = ...) -> dtype[ubyte]: ...
@overload
def __new__(cls, dtype: _UShortCodes | Type[ct.c_ushort], align: bool = ..., copy: bool = ...) -> dtype[ushort]: ...
@overload
def __new__(cls, dtype: _UIntCCodes | Type[ct.c_uint], align: bool = ..., copy: bool = ...) -> dtype[uintc]: ...
# NOTE: We're assuming here that `uint_ptr_t == size_t`,
# an assumption that does not hold in rare cases (same for `ssize_t`)
@overload
def __new__(cls, dtype: _UIntPCodes | Type[ct.c_void_p] | Type[ct.c_size_t], align: bool = ..., copy: bool = ...) -> dtype[uintp]: ...
@overload
def __new__(cls, dtype: _UIntCodes | Type[ct.c_ulong], align: bool = ..., copy: bool = ...) -> dtype[uint]: ...
@overload
def __new__(cls, dtype: _ULongLongCodes | Type[ct.c_ulonglong], align: bool = ..., copy: bool = ...) -> dtype[ulonglong]: ...
# `signedinteger` string-based representations and ctypes
@overload
def __new__(cls, dtype: _Int8Codes | Type[ct.c_int8], align: bool = ..., copy: bool = ...) -> dtype[int8]: ...
@overload
def __new__(cls, dtype: _Int16Codes | Type[ct.c_int16], align: bool = ..., copy: bool = ...) -> dtype[int16]: ...
@overload
def __new__(cls, dtype: _Int32Codes | Type[ct.c_int32], align: bool = ..., copy: bool = ...) -> dtype[int32]: ...
@overload
def __new__(cls, dtype: _Int64Codes | Type[ct.c_int64], align: bool = ..., copy: bool = ...) -> dtype[int64]: ...
@overload
def __new__(cls, dtype: _ByteCodes | Type[ct.c_byte], align: bool = ..., copy: bool = ...) -> dtype[byte]: ...
@overload
def __new__(cls, dtype: _ShortCodes | Type[ct.c_short], align: bool = ..., copy: bool = ...) -> dtype[short]: ...
@overload
def __new__(cls, dtype: _IntCCodes | Type[ct.c_int], align: bool = ..., copy: bool = ...) -> dtype[intc]: ...
@overload
def __new__(cls, dtype: _IntPCodes | Type[ct.c_ssize_t], align: bool = ..., copy: bool = ...) -> dtype[intp]: ...
@overload
def __new__(cls, dtype: _IntCodes | Type[ct.c_long], align: bool = ..., copy: bool = ...) -> dtype[int_]: ...
@overload
def __new__(cls, dtype: _LongLongCodes | Type[ct.c_longlong], align: bool = ..., copy: bool = ...) -> dtype[longlong]: ...
# `floating` string-based representations and ctypes
@overload
def __new__(cls, dtype: _Float16Codes, align: bool = ..., copy: bool = ...) -> dtype[float16]: ...
@overload
def __new__(cls, dtype: _Float32Codes, align: bool = ..., copy: bool = ...) -> dtype[float32]: ...
@overload
def __new__(cls, dtype: _Float64Codes, align: bool = ..., copy: bool = ...) -> dtype[float64]: ...
@overload
def __new__(cls, dtype: _HalfCodes, align: bool = ..., copy: bool = ...) -> dtype[half]: ...
@overload
def __new__(cls, dtype: _SingleCodes | Type[ct.c_float], align: bool = ..., copy: bool = ...) -> dtype[single]: ...
@overload
def __new__(cls, dtype: _DoubleCodes | Type[ct.c_double], align: bool = ..., copy: bool = ...) -> dtype[double]: ...
@overload
def __new__(cls, dtype: _LongDoubleCodes | Type[ct.c_longdouble], align: bool = ..., copy: bool = ...) -> dtype[longdouble]: ...
# `complexfloating` string-based representations
@overload
def __new__(cls, dtype: _Complex64Codes, align: bool = ..., copy: bool = ...) -> dtype[complex64]: ...
@overload
def __new__(cls, dtype: _Complex128Codes, align: bool = ..., copy: bool = ...) -> dtype[complex128]: ...
@overload
def __new__(cls, dtype: _CSingleCodes, align: bool = ..., copy: bool = ...) -> dtype[csingle]: ...
@overload
def __new__(cls, dtype: _CDoubleCodes, align: bool = ..., copy: bool = ...) -> dtype[cdouble]: ...
@overload
def __new__(cls, dtype: _CLongDoubleCodes, align: bool = ..., copy: bool = ...) -> dtype[clongdouble]: ...
# Miscellaneous string-based representations and ctypes
@overload
def __new__(cls, dtype: _BoolCodes | Type[ct.c_bool], align: bool = ..., copy: bool = ...) -> dtype[bool_]: ...
@overload
def __new__(cls, dtype: _TD64Codes, align: bool = ..., copy: bool = ...) -> dtype[timedelta64]: ...
@overload
def __new__(cls, dtype: _DT64Codes, align: bool = ..., copy: bool = ...) -> dtype[datetime64]: ...
@overload
def __new__(cls, dtype: _StrCodes, align: bool = ..., copy: bool = ...) -> dtype[str_]: ...
@overload
def __new__(cls, dtype: _BytesCodes | Type[ct.c_char], align: bool = ..., copy: bool = ...) -> dtype[bytes_]: ...
@overload
def __new__(cls, dtype: _VoidCodes, align: bool = ..., copy: bool = ...) -> dtype[void]: ...
@overload
def __new__(cls, dtype: _ObjectCodes | Type[ct.py_object], align: bool = ..., copy: bool = ...) -> dtype[object_]: ...
# dtype of a dtype is the same dtype
@overload
def __new__(
cls,
dtype: dtype[_DTypeScalar_co],
align: bool = ...,
copy: bool = ...,
) -> dtype[_DTypeScalar_co]: ...
@overload
def __new__(
cls,
dtype: _SupportsDType[dtype[_DTypeScalar_co]],
align: bool = ...,
copy: bool = ...,
) -> dtype[_DTypeScalar_co]: ...
# Handle strings that can't be expressed as literals; i.e. s1, s2, ...
@overload
def __new__(
cls,
dtype: builtins.str,
align: bool = ...,
copy: bool = ...,
) -> dtype[Any]: ...
# Catchall overload for void-likes
@overload
def __new__(
cls,
dtype: _VoidDTypeLike,
align: bool = ...,
copy: bool = ...,
) -> dtype[void]: ...
# Catchall overload for object-likes
@overload
def __new__(
cls,
dtype: Type[object],
align: bool = ...,
copy: bool = ...,
) -> dtype[object_]: ...
if sys.version_info >= (3, 9):
def __class_getitem__(self, item: Any) -> GenericAlias: ...
@overload
def __getitem__(self: dtype[void], key: List[builtins.str]) -> dtype[void]: ...
@overload
def __getitem__(self: dtype[void], key: builtins.str | SupportsIndex) -> dtype[Any]: ...
# NOTE: In the future 1-based multiplications will also yield `flexible` dtypes
@overload
def __mul__(self: _DType, value: L[1]) -> _DType: ...
@overload
def __mul__(self: _FlexDType, value: SupportsIndex) -> _FlexDType: ...
@overload
def __mul__(self, value: SupportsIndex) -> dtype[void]: ...
# NOTE: `__rmul__` seems to be broken when used in combination with
# literals as of mypy 0.902. Set the return-type to `dtype[Any]` for
# now for non-flexible dtypes.
@overload
def __rmul__(self: _FlexDType, value: SupportsIndex) -> _FlexDType: ...
@overload
def __rmul__(self, value: SupportsIndex) -> dtype[Any]: ...
def __gt__(self, other: DTypeLike) -> bool: ...
def __ge__(self, other: DTypeLike) -> bool: ...
def __lt__(self, other: DTypeLike) -> bool: ...
def __le__(self, other: DTypeLike) -> bool: ...
# Explicitly defined `__eq__` and `__ne__` to get around mypy's
# `strict_equality` option; even though their signatures are
# identical to their `object`-based counterpart
def __eq__(self, other: Any) -> bool: ...
def __ne__(self, other: Any) -> bool: ...
@property
def alignment(self) -> int: ...
@property
def base(self) -> dtype[Any]: ...
@property
def byteorder(self) -> builtins.str: ...
@property
def char(self) -> builtins.str: ...
@property
def descr(self) -> List[Tuple[builtins.str, builtins.str] | Tuple[builtins.str, builtins.str, _Shape]]: ...
@property
def fields(
self,
) -> None | MappingProxyType[builtins.str, Tuple[dtype[Any], int] | Tuple[dtype[Any], int, Any]]: ...
@property
def flags(self) -> int: ...
@property
def hasobject(self) -> bool: ...
@property
def isbuiltin(self) -> int: ...
@property
def isnative(self) -> bool: ...
@property
def isalignedstruct(self) -> bool: ...
@property
def itemsize(self) -> int: ...
@property
def kind(self) -> builtins.str: ...
@property
def metadata(self) -> None | MappingProxyType[builtins.str, Any]: ...
@property
def name(self) -> builtins.str: ...
@property
def num(self) -> int: ...
@property
def shape(self) -> _Shape: ...
@property
def ndim(self) -> int: ...
@property
def subdtype(self) -> None | Tuple[dtype[Any], _Shape]: ...
def newbyteorder(self: _DType, __new_order: _ByteOrder = ...) -> _DType: ...
@property
def str(self) -> builtins.str: ...
@property
def type(self) -> Type[_DTypeScalar_co]: ...
_ArrayLikeInt = Union[
int,
integer,
Sequence[Union[int, integer]],
Sequence[Sequence[Any]], # TODO: wait for support for recursive types
ndarray
]
_FlatIterSelf = TypeVar("_FlatIterSelf", bound=flatiter)
class flatiter(Generic[_NdArraySubClass]):
@property
def base(self) -> _NdArraySubClass: ...
@property
def coords(self) -> _Shape: ...
@property
def index(self) -> int: ...
def copy(self) -> _NdArraySubClass: ...
def __iter__(self: _FlatIterSelf) -> _FlatIterSelf: ...
def __next__(self: flatiter[ndarray[Any, dtype[_ScalarType]]]) -> _ScalarType: ...
def __len__(self) -> int: ...
@overload
def __getitem__(
self: flatiter[ndarray[Any, dtype[_ScalarType]]],
key: Union[int, integer],
) -> _ScalarType: ...
@overload
def __getitem__(
self, key: Union[_ArrayLikeInt, slice, ellipsis],
) -> _NdArraySubClass: ...
@overload
def __array__(self: flatiter[ndarray[Any, _DType]], dtype: None = ..., /) -> ndarray[Any, _DType]: ...
@overload
def __array__(self, dtype: _DType, /) -> ndarray[Any, _DType]: ...
_OrderKACF = Optional[L["K", "A", "C", "F"]]
_OrderACF = Optional[L["A", "C", "F"]]
_OrderCF = Optional[L["C", "F"]]
_ModeKind = L["raise", "wrap", "clip"]
_PartitionKind = L["introselect"]
_SortKind = L["quicksort", "mergesort", "heapsort", "stable"]
_SortSide = L["left", "right"]
_ArraySelf = TypeVar("_ArraySelf", bound=_ArrayOrScalarCommon)
class _ArrayOrScalarCommon:
@property
def T(self: _ArraySelf) -> _ArraySelf: ...
@property
def data(self) -> memoryview: ...
@property
def flags(self) -> flagsobj: ...
@property
def itemsize(self) -> int: ...
@property
def nbytes(self) -> int: ...
def __bool__(self) -> bool: ...
def __bytes__(self) -> bytes: ...
def __str__(self) -> str: ...
def __repr__(self) -> str: ...
def __copy__(self: _ArraySelf) -> _ArraySelf: ...
def __deepcopy__(self: _ArraySelf, memo: None | Dict[int, Any], /) -> _ArraySelf: ...
# TODO: How to deal with the non-commutative nature of `==` and `!=`?
# xref numpy/numpy#17368
def __eq__(self, other: Any) -> Any: ...
def __ne__(self, other: Any) -> Any: ...
def copy(self: _ArraySelf, order: _OrderKACF = ...) -> _ArraySelf: ...
def dump(self, file: str | bytes | os.PathLike[str] | os.PathLike[bytes] | _SupportsWrite[bytes]) -> None: ...
def dumps(self) -> bytes: ...
def tobytes(self, order: _OrderKACF = ...) -> bytes: ...