codekingpro/portable-devtools
114k
1# TODO: Sort out any and all missing functions in this namespace
2import datetime as dt
3from _typeshed import Incomplete, StrOrBytesPath, SupportsLenAndGetItem
4from collections.abc import Callable, Iterable, Sequence
5from typing import (
6 Any,
7 ClassVar,
8 Final,
9 Literal as L,
10 Protocol,
11 SupportsIndex,
12 TypeAlias,
13 TypeVar,
14 final,
15 overload,
16 type_check_only,
17)
18from typing_extensions import CapsuleType
19
20import numpy as np
21from numpy import ( # type: ignore[attr-defined] # Python >=3.12
22 _AnyShapeT,
23 _CastingKind,
24 _CopyMode,
25 _ModeKind,
26 _NDIterFlagsKind,
27 _NDIterFlagsOp,
28 _OrderCF,
29 _OrderKACF,
30 _SupportsBuffer,
31 _SupportsFileMethods,
32 broadcast,
33 busdaycalendar,
34 complexfloating,
35 correlate,
36 count_nonzero,
37 datetime64,
38 dtype,
39 einsum as c_einsum,
40 flatiter,
41 float64,
42 floating,
43 from_dlpack,
44 generic,
45 int_,
46 interp,
47 intp,
48 matmul,
49 ndarray,
50 nditer,
51 signedinteger,
52 str_,
53 timedelta64,
54 ufunc,
55 uint8,
56 unsignedinteger,
57 vecdot,
58)
59from numpy._typing import (
60 ArrayLike,
61 DTypeLike,
62 NDArray,
63 _AnyShape,
64 _ArrayLike,
65 _ArrayLikeBool_co,
66 _ArrayLikeBytes_co,
67 _ArrayLikeComplex_co,
68 _ArrayLikeDT64_co,
69 _ArrayLikeFloat_co,
70 _ArrayLikeInt_co,
71 _ArrayLikeObject_co,
72 _ArrayLikeStr_co,
73 _ArrayLikeTD64_co,
74 _ArrayLikeUInt_co,
75 _DT64Codes,
76 _DTypeLike,
77 _FloatLike_co,
78 _IntLike_co,
79 _NestedSequence,
80 _ScalarLike_co,
81 _Shape,
82 _ShapeLike,
83 _SupportsArrayFunc,
84 _SupportsDType,
85 _TD64Like_co,
86)
87from numpy._typing._ufunc import (
88 _2PTuple,
89 _PyFunc_Nin1_Nout1,
90 _PyFunc_Nin1P_Nout2P,
91 _PyFunc_Nin2_Nout1,
92 _PyFunc_Nin3P_Nout1,
93)
94
95__all__ = [
96 "_ARRAY_API",
97 "ALLOW_THREADS",
98 "BUFSIZE",
99 "CLIP",
100 "DATETIMEUNITS",
101 "ITEM_HASOBJECT",
102 "ITEM_IS_POINTER",
103 "LIST_PICKLE",
104 "MAXDIMS",
105 "MAY_SHARE_BOUNDS",
106 "MAY_SHARE_EXACT",
107 "NEEDS_INIT",
108 "NEEDS_PYAPI",
109 "RAISE",
110 "USE_GETITEM",
111 "USE_SETITEM",
112 "WRAP",
113 "_flagdict",
114 "from_dlpack",
115 "_place",
116 "_reconstruct",
117 "_vec_string",
118 "_monotonicity",
119 "add_docstring",
120 "arange",
121 "array",
122 "asarray",
123 "asanyarray",
124 "ascontiguousarray",
125 "asfortranarray",
126 "bincount",
127 "broadcast",
128 "busday_count",
129 "busday_offset",
130 "busdaycalendar",
131 "can_cast",
132 "compare_chararrays",
133 "concatenate",
134 "copyto",
135 "correlate",
136 "correlate2",
137 "count_nonzero",
138 "c_einsum",
139 "datetime_as_string",
140 "datetime_data",
141 "dot",
142 "dragon4_positional",
143 "dragon4_scientific",
144 "dtype",
145 "empty",
146 "empty_like",
147 "error",
148 "flagsobj",
149 "flatiter",
150 "format_longfloat",
151 "frombuffer",
152 "fromfile",
153 "fromiter",
154 "fromstring",
155 "get_handler_name",
156 "get_handler_version",
157 "inner",
158 "interp",
159 "interp_complex",
160 "is_busday",
161 "lexsort",
162 "matmul",
163 "vecdot",
164 "may_share_memory",
165 "min_scalar_type",
166 "ndarray",
167 "nditer",
168 "nested_iters",
169 "normalize_axis_index",
170 "packbits",
171 "promote_types",
172 "putmask",
173 "ravel_multi_index",
174 "result_type",
175 "scalar",
176 "set_datetimeparse_function",
177 "set_typeDict",
178 "shares_memory",
179 "typeinfo",
180 "unpackbits",
181 "unravel_index",
182 "vdot",
183 "where",
184 "zeros",
185]
186
187_ScalarT = TypeVar("_ScalarT", bound=generic)
188_DTypeT = TypeVar("_DTypeT", bound=np.dtype)
189_ArrayT = TypeVar("_ArrayT", bound=ndarray)
190_ArrayT_co = TypeVar("_ArrayT_co", bound=ndarray, covariant=True)
191_ShapeT = TypeVar("_ShapeT", bound=_Shape)
192# TODO: fix the names of these typevars
193_ReturnType = TypeVar("_ReturnType")
194_IDType = TypeVar("_IDType")
195_Nin = TypeVar("_Nin", bound=int)
196_Nout = TypeVar("_Nout", bound=int)
197
198_Array: TypeAlias = ndarray[_ShapeT, dtype[_ScalarT]]
199_Array1D: TypeAlias = ndarray[tuple[int], dtype[_ScalarT]]
200
201# Valid time units
202_UnitKind: TypeAlias = L[
203 "Y",
204 "M",
205 "D",
206 "h",
207 "m",
208 "s",
209 "ms",
210 "us", "μs",
211 "ns",
212 "ps",
213 "fs",
214 "as",
215]
216_RollKind: TypeAlias = L[ # `raise` is deliberately excluded
217 "nat",
218 "forward",
219 "following",
220 "backward",
221 "preceding",
222 "modifiedfollowing",
223 "modifiedpreceding",
224]
225
226@type_check_only
227class _SupportsArray(Protocol[_ArrayT_co]):
228 def __array__(self, /) -> _ArrayT_co: ...
229
230@type_check_only
231class _ConstructorEmpty(Protocol):
232 # 1-D shape
233 @overload
234 def __call__(
235 self,
236 /,
237 shape: SupportsIndex,
238 dtype: None = None,
239 order: _OrderCF = "C",
240 *,
241 device: L["cpu"] | None = None,
242 like: _SupportsArrayFunc | None = None,
243 ) -> _Array1D[float64]: ...
244 @overload
245 def __call__(
246 self,
247 /,
248 shape: SupportsIndex,
249 dtype: _DTypeT | _SupportsDType[_DTypeT],
250 order: _OrderCF = "C",
251 *,
252 device: L["cpu"] | None = None,
253 like: _SupportsArrayFunc | None = None,
254 ) -> ndarray[tuple[int], _DTypeT]: ...
255 @overload
256 def __call__(
257 self,
258 /,
259 shape: SupportsIndex,
260 dtype: type[_ScalarT],
261 order: _OrderCF = "C",
262 *,
263 device: L["cpu"] | None = None,
264 like: _SupportsArrayFunc | None = None,
265 ) -> _Array1D[_ScalarT]: ...
266 @overload
267 def __call__(
268 self,
269 /,
270 shape: SupportsIndex,
271 dtype: DTypeLike | None = None,
272 order: _OrderCF = "C",
273 *,
274 device: L["cpu"] | None = None,
275 like: _SupportsArrayFunc | None = None,
276 ) -> _Array1D[Incomplete]: ...
277
278 # known shape
279 @overload
280 def __call__(
281 self,
282 /,
283 shape: _AnyShapeT,
284 dtype: None = None,
285 order: _OrderCF = "C",
286 *,
287 device: L["cpu"] | None = None,
288 like: _SupportsArrayFunc | None = None,
289 ) -> _Array[_AnyShapeT, float64]: ...
290 @overload
291 def __call__(
292 self,
293 /,
294 shape: _AnyShapeT,
295 dtype: _DTypeT | _SupportsDType[_DTypeT],
296 order: _OrderCF = "C",
297 *,
298 device: L["cpu"] | None = None,
299 like: _SupportsArrayFunc | None = None,
300 ) -> ndarray[_AnyShapeT, _DTypeT]: ...
301 @overload
302 def __call__(
303 self,
304 /,
305 shape: _AnyShapeT,
306 dtype: type[_ScalarT],
307 order: _OrderCF = "C",
308 *,
309 device: L["cpu"] | None = None,
310 like: _SupportsArrayFunc | None = None,
311 ) -> _Array[_AnyShapeT, _ScalarT]: ...
312 @overload
313 def __call__(
314 self,
315 /,
316 shape: _AnyShapeT,
317 dtype: DTypeLike | None = None,
318 order: _OrderCF = "C",
319 *,
320 device: L["cpu"] | None = None,
321 like: _SupportsArrayFunc | None = None,
322 ) -> _Array[_AnyShapeT, Incomplete]: ...
323
324 # unknown shape
325 @overload
326 def __call__(
327 self, /,
328 shape: _ShapeLike,
329 dtype: None = None,
330 order: _OrderCF = "C",
331 *,
332 device: L["cpu"] | None = None,
333 like: _SupportsArrayFunc | None = None,
334 ) -> NDArray[float64]: ...
335 @overload
336 def __call__(
337 self, /,
338 shape: _ShapeLike,
339 dtype: _DTypeT | _SupportsDType[_DTypeT],
340 order: _OrderCF = "C",
341 *,
342 device: L["cpu"] | None = None,
343 like: _SupportsArrayFunc | None = None,
344 ) -> ndarray[_AnyShape, _DTypeT]: ...
345 @overload
346 def __call__(
347 self, /,
348 shape: _ShapeLike,
349 dtype: type[_ScalarT],
350 order: _OrderCF = "C",
351 *,
352 device: L["cpu"] | None = None,
353 like: _SupportsArrayFunc | None = None,
354 ) -> NDArray[_ScalarT]: ...
355 @overload
356 def __call__(
357 self,
358 /,
359 shape: _ShapeLike,
360 dtype: DTypeLike | None = None,
361 order: _OrderCF = "C",
362 *,
363 device: L["cpu"] | None = None,
364 like: _SupportsArrayFunc | None = None,
365 ) -> NDArray[Incomplete]: ...
366
367# using `Final` or `TypeAlias` will break stubtest
368error = Exception
369
370# from ._multiarray_umath
371ITEM_HASOBJECT: Final = 1
372LIST_PICKLE: Final = 2
373ITEM_IS_POINTER: Final = 4
374NEEDS_INIT: Final = 8
375NEEDS_PYAPI: Final = 16
376USE_GETITEM: Final = 32
377USE_SETITEM: Final = 64
378DATETIMEUNITS: Final[CapsuleType] = ...
379_ARRAY_API: Final[CapsuleType] = ...
380
381_flagdict: Final[dict[str, int]] = ...
382_monotonicity: Final[Callable[..., object]] = ...
383_place: Final[Callable[..., object]] = ...
384_reconstruct: Final[Callable[..., object]] = ...
385_vec_string: Final[Callable[..., object]] = ...
386correlate2: Final[Callable[..., object]] = ...
387dragon4_positional: Final[Callable[..., object]] = ...
388dragon4_scientific: Final[Callable[..., object]] = ...
389interp_complex: Final[Callable[..., object]] = ...
390set_datetimeparse_function: Final[Callable[..., object]] = ...
391
392def get_handler_name(a: NDArray[Any] = ..., /) -> str | None: ...
393def get_handler_version(a: NDArray[Any] = ..., /) -> int | None: ...
394def format_longfloat(x: np.longdouble, precision: int) -> str: ...
395def scalar(dtype: _DTypeT, object: bytes | object = ...) -> ndarray[tuple[()], _DTypeT]: ...
396def set_typeDict(dict_: dict[str, np.dtype], /) -> None: ...
397
398typeinfo: Final[dict[str, np.dtype[np.generic]]] = ...
399
400ALLOW_THREADS: Final[int] # 0 or 1 (system-specific)
401BUFSIZE: Final = 8_192
402CLIP: Final = 0
403WRAP: Final = 1
404RAISE: Final = 2
405MAXDIMS: Final = 64
406MAY_SHARE_BOUNDS: Final = 0
407MAY_SHARE_EXACT: Final = -1
408tracemalloc_domain: Final = 389_047
409
410zeros: Final[_ConstructorEmpty] = ...
411empty: Final[_ConstructorEmpty] = ...
412
413@overload
414def empty_like(
415 prototype: _ArrayT,
416 /,
417 dtype: None = None,
418 order: _OrderKACF = "K",
419 subok: bool = True,
420 shape: _ShapeLike | None = None,
421 *,
422 device: L["cpu"] | None = None,
423) -> _ArrayT: ...
424@overload
425def empty_like(
426 prototype: _ArrayLike[_ScalarT],
427 /,
428 dtype: None = None,
429 order: _OrderKACF = "K",
430 subok: bool = True,
431 shape: _ShapeLike | None = None,
432 *,
433 device: L["cpu"] | None = None,
434) -> NDArray[_ScalarT]: ...
435@overload
436def empty_like(
437 prototype: Incomplete,
438 /,
439 dtype: _DTypeLike[_ScalarT],
440 order: _OrderKACF = "K",
441 subok: bool = True,
442 shape: _ShapeLike | None = None,
443 *,
444 device: L["cpu"] | None = None,
445) -> NDArray[_ScalarT]: ...
446@overload
447def empty_like(
448 prototype: Incomplete,
449 /,
450 dtype: DTypeLike | None = None,
451 order: _OrderKACF = "K",
452 subok: bool = True,
453 shape: _ShapeLike | None = None,
454 *,
455 device: L["cpu"] | None = None,
456) -> NDArray[Incomplete]: ...
457
458@overload
459def array(
460 object: _ArrayT,
461 dtype: None = None,
462 *,
463 copy: bool | _CopyMode | None = True,
464 order: _OrderKACF = "K",
465 subok: L[True],
466 ndmin: int = 0,
467 ndmax: int = 0,
468 like: _SupportsArrayFunc | None = None,
469) -> _ArrayT: ...
470@overload
471def array(
472 object: _SupportsArray[_ArrayT],
473 dtype: None = None,
474 *,
475 copy: bool | _CopyMode | None = True,
476 order: _OrderKACF = "K",
477 subok: L[True],
478 ndmin: L[0] = 0,
479 ndmax: int = 0,
480 like: _SupportsArrayFunc | None = None,
481) -> _ArrayT: ...
482@overload
483def array(
484 object: _ArrayLike[_ScalarT],
485 dtype: None = None,
486 *,
487 copy: bool | _CopyMode | None = True,
488 order: _OrderKACF = "K",
489 subok: bool = False,
490 ndmin: int = 0,
491 ndmax: int = 0,
492 like: _SupportsArrayFunc | None = None,
493) -> NDArray[_ScalarT]: ...
494@overload
495def array(
496 object: Any,
497 dtype: _DTypeLike[_ScalarT],
498 *,
499 copy: bool | _CopyMode | None = True,
500 order: _OrderKACF = "K",
501 subok: bool = False,
502 ndmin: int = 0,
503 ndmax: int = 0,
504 like: _SupportsArrayFunc | None = None,
505) -> NDArray[_ScalarT]: ...
506@overload
507def array(
508 object: Any,
509 dtype: DTypeLike | None = None,
510 *,
511 copy: bool | _CopyMode | None = True,
512 order: _OrderKACF = "K",
513 subok: bool = False,
514 ndmin: int = 0,
515 ndmax: int = 0,
516 like: _SupportsArrayFunc | None = None,
517) -> NDArray[Any]: ...
518
519#
520@overload
521def ravel_multi_index(
522 multi_index: SupportsLenAndGetItem[_IntLike_co],
523 dims: _ShapeLike,
524 mode: _ModeKind | tuple[_ModeKind, ...] = "raise",
525 order: _OrderCF = "C",
526) -> intp: ...
527@overload
528def ravel_multi_index(
529 multi_index: SupportsLenAndGetItem[_ArrayLikeInt_co],
530 dims: _ShapeLike,
531 mode: _ModeKind | tuple[_ModeKind, ...] = "raise",
532 order: _OrderCF = "C",
533) -> NDArray[intp]: ...
534
535#
536@overload
537def unravel_index(indices: _IntLike_co, shape: _ShapeLike, order: _OrderCF = "C") -> tuple[intp, ...]: ...
538@overload
539def unravel_index(indices: _ArrayLikeInt_co, shape: _ShapeLike, order: _OrderCF = "C") -> tuple[NDArray[intp], ...]: ...
540
541#
542def normalize_axis_index(axis: int, ndim: int, msg_prefix: str | None = None) -> int: ...
543
544# NOTE: Allow any sequence of array-like objects
545@overload
546def concatenate(
547 arrays: _ArrayLike[_ScalarT],
548 /,
549 axis: SupportsIndex | None = 0,
550 out: None = None,
551 *,
552 dtype: None = None,
553 casting: _CastingKind | None = "same_kind",
554) -> NDArray[_ScalarT]: ...
555@overload
556def concatenate(
557 arrays: SupportsLenAndGetItem[ArrayLike],
558 /,
559 axis: SupportsIndex | None = 0,
560 out: None = None,
561 *,
562 dtype: _DTypeLike[_ScalarT],
563 casting: _CastingKind | None = "same_kind",
564) -> NDArray[_ScalarT]: ...
565@overload
566def concatenate(
567 arrays: SupportsLenAndGetItem[ArrayLike],
568 /,
569 axis: SupportsIndex | None = 0,
570 out: None = None,
571 *,
572 dtype: DTypeLike | None = None,
573 casting: _CastingKind | None = "same_kind",
574) -> NDArray[Incomplete]: ...
575@overload
576def concatenate(
577 arrays: SupportsLenAndGetItem[ArrayLike],
578 /,
579 axis: SupportsIndex | None = 0,
580 *,
581 out: _ArrayT,
582 dtype: DTypeLike | None = None,
583 casting: _CastingKind | None = "same_kind",
584) -> _ArrayT: ...
585@overload
586def concatenate(
587 arrays: SupportsLenAndGetItem[ArrayLike],
588 /,
589 axis: SupportsIndex | None,
590 out: _ArrayT,
591 *,
592 dtype: DTypeLike | None = None,
593 casting: _CastingKind | None = "same_kind",
594) -> _ArrayT: ...
595
596def inner(a: ArrayLike, b: ArrayLike, /) -> Incomplete: ...
597
598@overload
599def where(condition: ArrayLike, x: None = None, y: None = None, /) -> tuple[NDArray[intp], ...]: ...
600@overload
601def where(condition: ArrayLike, x: ArrayLike, y: ArrayLike, /) -> NDArray[Incomplete]: ...
602
603def lexsort(keys: ArrayLike, axis: SupportsIndex = -1) -> NDArray[intp]: ...
604
605def can_cast(from_: ArrayLike | DTypeLike, to: DTypeLike, casting: _CastingKind = "safe") -> bool: ...
606
607def min_scalar_type(a: ArrayLike, /) -> dtype: ...
608def result_type(*arrays_and_dtypes: ArrayLike | DTypeLike | None) -> dtype: ...
609
610@overload
611def dot(a: ArrayLike, b: ArrayLike, out: None = None) -> Incomplete: ...
612@overload
613def dot(a: ArrayLike, b: ArrayLike, out: _ArrayT) -> _ArrayT: ...
614
615@overload
616def vdot(a: _ArrayLikeBool_co, b: _ArrayLikeBool_co, /) -> np.bool: ...
617@overload
618def vdot(a: _ArrayLikeUInt_co, b: _ArrayLikeUInt_co, /) -> unsignedinteger: ...
619@overload
620def vdot(a: _ArrayLikeInt_co, b: _ArrayLikeInt_co, /) -> signedinteger: ...
621@overload
622def vdot(a: _ArrayLikeFloat_co, b: _ArrayLikeFloat_co, /) -> floating: ...
623@overload
624def vdot(a: _ArrayLikeComplex_co, b: _ArrayLikeComplex_co, /) -> complexfloating: ...
625@overload
626def vdot(a: _ArrayLikeTD64_co, b: _ArrayLikeTD64_co, /) -> timedelta64: ...
627@overload
628def vdot(a: _ArrayLikeObject_co, b: object, /) -> Any: ...
629@overload
630def vdot(a: object, b: _ArrayLikeObject_co, /) -> Any: ...
631
632def bincount(x: ArrayLike, /, weights: ArrayLike | None = None, minlength: SupportsIndex = 0) -> NDArray[intp]: ...
633
634def copyto(dst: ndarray, src: ArrayLike, casting: _CastingKind = "same_kind", where: object = True) -> None: ...
635def putmask(a: ndarray, /, mask: _ArrayLikeBool_co, values: ArrayLike) -> None: ...
636
637_BitOrder: TypeAlias = L["big", "little"]
638
639@overload
640def packbits(a: _ArrayLikeInt_co, /, axis: None = None, bitorder: _BitOrder = "big") -> ndarray[tuple[int], dtype[uint8]]: ...
641@overload
642def packbits(a: _ArrayLikeInt_co, /, axis: SupportsIndex, bitorder: _BitOrder = "big") -> NDArray[uint8]: ...
643
644@overload
645def unpackbits(
646 a: _ArrayLike[uint8],
647 /,
648 axis: None = None,
649 count: SupportsIndex | None = None,
650 bitorder: _BitOrder = "big",
651) -> ndarray[tuple[int], dtype[uint8]]: ...
652@overload
653def unpackbits(
654 a: _ArrayLike[uint8],
655 /,
656 axis: SupportsIndex,
657 count: SupportsIndex | None = None,
658 bitorder: _BitOrder = "big",
659) -> NDArray[uint8]: ...
660
661_MaxWork: TypeAlias = L[-1, 0]
662
663# any two python objects will be accepted, not just `ndarray`s
664def shares_memory(a: object, b: object, /, max_work: _MaxWork = -1) -> bool: ...
665def may_share_memory(a: object, b: object, /, max_work: _MaxWork = 0) -> bool: ...
666
667@overload
668def asarray(
669 a: _ArrayLike[_ScalarT],
670 dtype: None = None,
671 order: _OrderKACF = ...,
672 *,
673 device: L["cpu"] | None = ...,
674 copy: bool | None = ...,
675 like: _SupportsArrayFunc | None = ...,
676) -> NDArray[_ScalarT]: ...
677@overload
678def asarray(
679 a: Any,
680 dtype: _DTypeLike[_ScalarT],
681 order: _OrderKACF = ...,
682 *,
683 device: L["cpu"] | None = ...,
684 copy: bool | None = ...,
685 like: _SupportsArrayFunc | None = ...,
686) -> NDArray[_ScalarT]: ...
687@overload
688def asarray(
689 a: Any,
690 dtype: DTypeLike | None = ...,
691 order: _OrderKACF = ...,
692 *,
693 device: L["cpu"] | None = ...,
694 copy: bool | None = ...,
695 like: _SupportsArrayFunc | None = ...,
696) -> NDArray[Any]: ...
697
698@overload
699def asanyarray(
700 a: _ArrayT, # Preserve subclass-information
701 dtype: None = None,
702 order: _OrderKACF = ...,
703 *,
704 device: L["cpu"] | None = ...,
705 copy: bool | None = ...,
706 like: _SupportsArrayFunc | None = ...,
707) -> _ArrayT: ...
708@overload
709def asanyarray(
710 a: _ArrayLike[_ScalarT],
711 dtype: None = None,
712 order: _OrderKACF = ...,
713 *,
714 device: L["cpu"] | None = ...,
715 copy: bool | None = ...,
716 like: _SupportsArrayFunc | None = ...,
717) -> NDArray[_ScalarT]: ...
718@overload
719def asanyarray(
720 a: Any,
721 dtype: _DTypeLike[_ScalarT],
722 order: _OrderKACF = ...,
723 *,
724 device: L["cpu"] | None = ...,
725 copy: bool | None = ...,
726 like: _SupportsArrayFunc | None = ...,
727) -> NDArray[_ScalarT]: ...
728@overload
729def asanyarray(
730 a: Any,
731 dtype: DTypeLike | None = ...,
732 order: _OrderKACF = ...,
733 *,
734 device: L["cpu"] | None = ...,
735 copy: bool | None = ...,
736 like: _SupportsArrayFunc | None = ...,
737) -> NDArray[Any]: ...
738
739@overload
740def ascontiguousarray(
741 a: _ArrayLike[_ScalarT],
742 dtype: None = None,
743 *,
744 like: _SupportsArrayFunc | None = ...,
745) -> NDArray[_ScalarT]: ...
746@overload
747def ascontiguousarray(
748 a: Any,
749 dtype: _DTypeLike[_ScalarT],
750 *,
751 like: _SupportsArrayFunc | None = ...,
752) -> NDArray[_ScalarT]: ...
753@overload
754def ascontiguousarray(
755 a: Any,
756 dtype: DTypeLike | None = ...,
757 *,
758 like: _SupportsArrayFunc | None = ...,
759) -> NDArray[Any]: ...
760
761@overload
762def asfortranarray(
763 a: _ArrayLike[_ScalarT],
764 dtype: None = None,
765 *,
766 like: _SupportsArrayFunc | None = ...,
767) -> NDArray[_ScalarT]: ...
768@overload
769def asfortranarray(
770 a: Any,
771 dtype: _DTypeLike[_ScalarT],
772 *,
773 like: _SupportsArrayFunc | None = ...,
774) -> NDArray[_ScalarT]: ...
775@overload
776def asfortranarray(
777 a: Any,
778 dtype: DTypeLike | None = ...,
779 *,
780 like: _SupportsArrayFunc | None = ...,
781) -> NDArray[Any]: ...
782
783def promote_types(__type1: DTypeLike, __type2: DTypeLike) -> dtype: ...
784
785# `sep` is a de facto mandatory argument, as its default value is deprecated
786@overload
787def fromstring(
788 string: str | bytes,
789 dtype: None = None,
790 count: SupportsIndex = ...,
791 *,
792 sep: str,
793 like: _SupportsArrayFunc | None = ...,
794) -> NDArray[float64]: ...
795@overload
796def fromstring(
797 string: str | bytes,
798 dtype: _DTypeLike[_ScalarT],
799 count: SupportsIndex = ...,
800 *,
801 sep: str,
802 like: _SupportsArrayFunc | None = ...,
803) -> NDArray[_ScalarT]: ...
804@overload
805def fromstring(
806 string: str | bytes,
807 dtype: DTypeLike | None = ...,
808 count: SupportsIndex = ...,
809 *,
810 sep: str,
811 like: _SupportsArrayFunc | None = ...,
812) -> NDArray[Any]: ...
813
814@overload
815def frompyfunc( # type: ignore[overload-overlap]
816 func: Callable[[Any], _ReturnType], /,
817 nin: L[1],
818 nout: L[1],
819 *,
820 identity: None = None,
821) -> _PyFunc_Nin1_Nout1[_ReturnType, None]: ...
822@overload
823def frompyfunc( # type: ignore[overload-overlap]
824 func: Callable[[Any], _ReturnType], /,
825 nin: L[1],
826 nout: L[1],
827 *,
828 identity: _IDType,
829) -> _PyFunc_Nin1_Nout1[_ReturnType, _IDType]: ...
830@overload
831def frompyfunc( # type: ignore[overload-overlap]
832 func: Callable[[Any, Any], _ReturnType], /,
833 nin: L[2],
834 nout: L[1],
835 *,
836 identity: None = None,
837) -> _PyFunc_Nin2_Nout1[_ReturnType, None]: ...
838@overload
839def frompyfunc( # type: ignore[overload-overlap]
840 func: Callable[[Any, Any], _ReturnType], /,
841 nin: L[2],
842 nout: L[1],
843 *,
844 identity: _IDType,
845) -> _PyFunc_Nin2_Nout1[_ReturnType, _IDType]: ...
846@overload
847def frompyfunc( # type: ignore[overload-overlap]
848 func: Callable[..., _ReturnType], /,
849 nin: _Nin,
850 nout: L[1],
851 *,
852 identity: None = None,
853) -> _PyFunc_Nin3P_Nout1[_ReturnType, None, _Nin]: ...
854@overload
855def frompyfunc( # type: ignore[overload-overlap]
856 func: Callable[..., _ReturnType], /,
857 nin: _Nin,
858 nout: L[1],
859 *,
860 identity: _IDType,
861) -> _PyFunc_Nin3P_Nout1[_ReturnType, _IDType, _Nin]: ...
862@overload
863def frompyfunc(
864 func: Callable[..., _2PTuple[_ReturnType]], /,
865 nin: _Nin,
866 nout: _Nout,
867 *,
868 identity: None = None,
869) -> _PyFunc_Nin1P_Nout2P[_ReturnType, None, _Nin, _Nout]: ...
870@overload
871def frompyfunc(
872 func: Callable[..., _2PTuple[_ReturnType]], /,
873 nin: _Nin,
874 nout: _Nout,
875 *,
876 identity: _IDType,
877) -> _PyFunc_Nin1P_Nout2P[_ReturnType, _IDType, _Nin, _Nout]: ...
878@overload
879def frompyfunc(
880 func: Callable[..., Any], /,
881 nin: SupportsIndex,
882 nout: SupportsIndex,
883 *,
884 identity: object | None = ...,
885) -> ufunc: ...
886
887@overload
888def fromfile(
889 file: StrOrBytesPath | _SupportsFileMethods,
890 dtype: None = None,
891 count: SupportsIndex = ...,
892 sep: str = ...,
893 offset: SupportsIndex = ...,
894 *,
895 like: _SupportsArrayFunc | None = ...,
896) -> NDArray[float64]: ...
897@overload
898def fromfile(
899 file: StrOrBytesPath | _SupportsFileMethods,
900 dtype: _DTypeLike[_ScalarT],
901 count: SupportsIndex = ...,
902 sep: str = ...,
903 offset: SupportsIndex = ...,
904 *,
905 like: _SupportsArrayFunc | None = ...,
906) -> NDArray[_ScalarT]: ...
907@overload
908def fromfile(
909 file: StrOrBytesPath | _SupportsFileMethods,
910 dtype: DTypeLike | None = ...,
911 count: SupportsIndex = ...,
912 sep: str = ...,
913 offset: SupportsIndex = ...,
914 *,
915 like: _SupportsArrayFunc | None = ...,
916) -> NDArray[Any]: ...
917
918@overload
919def fromiter(
920 iter: Iterable[Any],
921 dtype: _DTypeLike[_ScalarT],
922 count: SupportsIndex = ...,
923 *,
924 like: _SupportsArrayFunc | None = ...,
925) -> NDArray[_ScalarT]: ...
926@overload
927def fromiter(
928 iter: Iterable[Any],
929 dtype: DTypeLike | None,
930 count: SupportsIndex = ...,
931 *,
932 like: _SupportsArrayFunc | None = ...,
933) -> NDArray[Any]: ...
934
935@overload
936def frombuffer(
937 buffer: _SupportsBuffer,
938 dtype: None = None,
939 count: SupportsIndex = ...,
940 offset: SupportsIndex = ...,
941 *,
942 like: _SupportsArrayFunc | None = ...,
943) -> NDArray[float64]: ...
944@overload
945def frombuffer(
946 buffer: _SupportsBuffer,
947 dtype: _DTypeLike[_ScalarT],
948 count: SupportsIndex = ...,
949 offset: SupportsIndex = ...,
950 *,
951 like: _SupportsArrayFunc | None = ...,
952) -> NDArray[_ScalarT]: ...
953@overload
954def frombuffer(
955 buffer: _SupportsBuffer,
956 dtype: DTypeLike | None = ...,
957 count: SupportsIndex = ...,
958 offset: SupportsIndex = ...,
959 *,
960 like: _SupportsArrayFunc | None = ...,
961) -> NDArray[Any]: ...
962
963_ArangeScalar: TypeAlias = np.integer | np.floating | np.datetime64 | np.timedelta64
964_ArangeScalarT = TypeVar("_ArangeScalarT", bound=_ArangeScalar)
965
966# keep in sync with ma.core.arange
967# NOTE: The `float64 | Any` return types needed to avoid incompatible overlapping overloads
968@overload # dtype=<known>
969def arange(
970 start_or_stop: _ArangeScalar | float,
971 /,
972 stop: _ArangeScalar | float | None = None,
973 step: _ArangeScalar | float | None = 1,
974 *,
975 dtype: _DTypeLike[_ArangeScalarT],
976 device: L["cpu"] | None = None,
977 like: _SupportsArrayFunc | None = None,
978) -> _Array1D[_ArangeScalarT]: ...
979@overload # (int-like, int-like?, int-like?)
980def arange(
981 start_or_stop: _IntLike_co,
982 /,
983 stop: _IntLike_co | None = None,
984 step: _IntLike_co | None = 1,
985 *,
986 dtype: type[int] | _DTypeLike[np.int_] | None = None,
987 device: L["cpu"] | None = None,
988 like: _SupportsArrayFunc | None = None,
989) -> _Array1D[np.int_]: ...
990@overload # (float, float-like?, float-like?)
991def arange(
992 start_or_stop: float | floating,
993 /,
994 stop: _FloatLike_co | None = None,
995 step: _FloatLike_co | None = 1,
996 *,
997 dtype: type[float] | _DTypeLike[np.float64] | None = None,
998 device: L["cpu"] | None = None,
999 like: _SupportsArrayFunc | None = None,
1000) -> _Array1D[np.float64 | Any]: ...
1001@overload # (float-like, float, float-like?)
1002def arange(
1003 start_or_stop: _FloatLike_co,
1004 /,
1005 stop: float | floating,
1006 step: _FloatLike_co | None = 1,
1007 *,
1008 dtype: type[float] | _DTypeLike[np.float64] | None = None,
1009 device: L["cpu"] | None = None,
1010 like: _SupportsArrayFunc | None = None,
1011) -> _Array1D[np.float64 | Any]: ...
1012@overload # (timedelta, timedelta-like?, timedelta-like?)
1013def arange(
1014 start_or_stop: np.timedelta64,
1015 /,
1016 stop: _TD64Like_co | None = None,
1017 step: _TD64Like_co | None = 1,
1018 *,
1019 dtype: _DTypeLike[np.timedelta64] | None = None,
1020 device: L["cpu"] | None = None,
1021 like: _SupportsArrayFunc | None = None,
1022) -> _Array1D[np.timedelta64[Incomplete]]: ...
1023@overload # (timedelta-like, timedelta, timedelta-like?)
1024def arange(
1025 start_or_stop: _TD64Like_co,
1026 /,
1027 stop: np.timedelta64,
1028 step: _TD64Like_co | None = 1,
1029 *,
1030 dtype: _DTypeLike[np.timedelta64] | None = None,
1031 device: L["cpu"] | None = None,
1032 like: _SupportsArrayFunc | None = None,
1033) -> _Array1D[np.timedelta64[Incomplete]]: ...
1034@overload # (datetime, datetime, timedelta-like) (requires both start and stop)
1035def arange(
1036 start_or_stop: np.datetime64,
1037 /,
1038 stop: np.datetime64,
1039 step: _TD64Like_co | None = 1,
1040 *,
1041 dtype: _DTypeLike[np.datetime64] | None = None,
1042 device: L["cpu"] | None = None,
1043 like: _SupportsArrayFunc | None = None,
1044) -> _Array1D[np.datetime64[Incomplete]]: ...
1045@overload # (str, str, timedelta-like, dtype=dt64-like) (requires both start and stop)
1046def arange(
1047 start_or_stop: str,
1048 /,
1049 stop: str,
1050 step: _TD64Like_co | None = 1,
1051 *,
1052 dtype: _DTypeLike[np.datetime64] | _DT64Codes,
1053 device: L["cpu"] | None = None,
1054 like: _SupportsArrayFunc | None = None,
1055) -> _Array1D[np.datetime64[Incomplete]]: ...
1056@overload # dtype=<unknown>
1057def arange(
1058 start_or_stop: _ArangeScalar | float | str,
1059 /,
1060 stop: _ArangeScalar | float | str | None = None,
1061 step: _ArangeScalar | float | None = 1,
1062 *,
1063 dtype: DTypeLike | None = None,
1064 device: L["cpu"] | None = None,
1065 like: _SupportsArrayFunc | None = None,
1066) -> _Array1D[Incomplete]: ...
1067
1068#
1069def datetime_data(dtype: str | _DTypeLike[datetime64 | timedelta64], /) -> tuple[str, int]: ...
1070
1071# The datetime functions perform unsafe casts to `datetime64[D]`,
1072# so a lot of different argument types are allowed here
1073
1074_ToDates: TypeAlias = dt.date | _NestedSequence[dt.date]
1075_ToDeltas: TypeAlias = dt.timedelta | _NestedSequence[dt.timedelta]
1076
1077@overload
1078def busday_count(
1079 begindates: _ScalarLike_co | dt.date,
1080 enddates: _ScalarLike_co | dt.date,
1081 weekmask: ArrayLike = "1111100",
1082 holidays: ArrayLike | _ToDates = (),
1083 busdaycal: busdaycalendar | None = None,
1084 out: None = None,
1085) -> int_: ...
1086@overload
1087def busday_count(
1088 begindates: ArrayLike | _ToDates,
1089 enddates: ArrayLike | _ToDates,
1090 weekmask: ArrayLike = "1111100",
1091 holidays: ArrayLike | _ToDates = (),
1092 busdaycal: busdaycalendar | None = None,
1093 out: None = None,
1094) -> NDArray[int_]: ...
1095@overload
1096def busday_count(
1097 begindates: ArrayLike | _ToDates,
1098 enddates: ArrayLike | _ToDates,
1099 weekmask: ArrayLike = "1111100",
1100 holidays: ArrayLike | _ToDates = (),
1101 busdaycal: busdaycalendar | None = None,
1102 *,
1103 out: _ArrayT,
1104) -> _ArrayT: ...
1105@overload
1106def busday_count(
1107 begindates: ArrayLike | _ToDates,
1108 enddates: ArrayLike | _ToDates,
1109 weekmask: ArrayLike,
1110 holidays: ArrayLike | _ToDates,
1111 busdaycal: busdaycalendar | None,
1112 out: _ArrayT,
1113) -> _ArrayT: ...
1114
1115# `roll="raise"` is (more or less?) equivalent to `casting="safe"`
1116@overload
1117def busday_offset(
1118 dates: datetime64 | dt.date,
1119 offsets: _TD64Like_co | dt.timedelta,
1120 roll: L["raise"] = "raise",
1121 weekmask: ArrayLike = "1111100",
1122 holidays: ArrayLike | _ToDates | None = None,
1123 busdaycal: busdaycalendar | None = None,
1124 out: None = None,
1125) -> datetime64: ...
1126@overload
1127def busday_offset(
1128 dates: _ArrayLike[datetime64] | _NestedSequence[dt.date],
1129 offsets: _ArrayLikeTD64_co | _ToDeltas,
1130 roll: L["raise"] = "raise",
1131 weekmask: ArrayLike = "1111100",
1132 holidays: ArrayLike | _ToDates | None = None,
1133 busdaycal: busdaycalendar | None = None,
1134 out: None = None,
1135) -> NDArray[datetime64]: ...
1136@overload
1137def busday_offset(
1138 dates: _ArrayLike[datetime64] | _ToDates,
1139 offsets: _ArrayLikeTD64_co | _ToDeltas,
1140 roll: L["raise"] = "raise",
1141 weekmask: ArrayLike = "1111100",
1142 holidays: ArrayLike | _ToDates | None = None,
1143 busdaycal: busdaycalendar | None = None,
1144 *,
1145 out: _ArrayT,
1146) -> _ArrayT: ...
1147@overload
1148def busday_offset(
1149 dates: _ArrayLike[datetime64] | _ToDates,
1150 offsets: _ArrayLikeTD64_co | _ToDeltas,
1151 roll: L["raise"],
1152 weekmask: ArrayLike,
1153 holidays: ArrayLike | _ToDates | None,
1154 busdaycal: busdaycalendar | None,
1155 out: _ArrayT,
1156) -> _ArrayT: ...
1157@overload
1158def busday_offset(
1159 dates: _ScalarLike_co | dt.date,
1160 offsets: _ScalarLike_co | dt.timedelta,
1161 roll: _RollKind,
1162 weekmask: ArrayLike = "1111100",
1163 holidays: ArrayLike | _ToDates | None = None,
1164 busdaycal: busdaycalendar | None = None,
1165 out: None = None,
1166) -> datetime64: ...
1167@overload
1168def busday_offset(
1169 dates: ArrayLike | _NestedSequence[dt.date],
1170 offsets: ArrayLike | _ToDeltas,
1171 roll: _RollKind,
1172 weekmask: ArrayLike = "1111100",
1173 holidays: ArrayLike | _ToDates | None = None,
1174 busdaycal: busdaycalendar | None = None,
1175 out: None = None,
1176) -> NDArray[datetime64]: ...
1177@overload
1178def busday_offset(
1179 dates: ArrayLike | _ToDates,
1180 offsets: ArrayLike | _ToDeltas,
1181 roll: _RollKind,
1182 weekmask: ArrayLike = "1111100",
1183 holidays: ArrayLike | _ToDates | None = None,
1184 busdaycal: busdaycalendar | None = None,
1185 *,
1186 out: _ArrayT,
1187) -> _ArrayT: ...
1188@overload
1189def busday_offset(
1190 dates: ArrayLike | _ToDates,
1191 offsets: ArrayLike | _ToDeltas,
1192 roll: _RollKind,
1193 weekmask: ArrayLike,
1194 holidays: ArrayLike | _ToDates | None,
1195 busdaycal: busdaycalendar | None,
1196 out: _ArrayT,
1197) -> _ArrayT: ...
1198
1199@overload
1200def is_busday(