1  # TODO: Sort out any and all missing functions in this namespace
   2  
   3  import os
   4  import datetime as dt
   5  from collections.abc import Sequence, Callable, Iterable
   6  from typing import (
   7      Literal as L,
   8      Any,
   9      overload,
  10      TypeVar,
  11      SupportsIndex,
  12      final,
  13      Final,
  14      Protocol,
  15      ClassVar,
  16  )
  17  
  18  from numpy import (
  19      # Re-exports
  20      busdaycalendar as busdaycalendar,
  21      broadcast as broadcast,
  22      dtype as dtype,
  23      ndarray as ndarray,
  24      nditer as nditer,
  25  
  26      # The rest
  27      ufunc,
  28      str_,
  29      bool_,
  30      uint8,
  31      intp,
  32      int_,
  33      float64,
  34      timedelta64,
  35      datetime64,
  36      generic,
  37      unsignedinteger,
  38      signedinteger,
  39      floating,
  40      complexfloating,
  41      _OrderKACF,
  42      _OrderCF,
  43      _CastingKind,
  44      _ModeKind,
  45      _SupportsBuffer,
  46      _IOProtocol,
  47      _CopyMode,
  48      _NDIterFlagsKind,
  49      _NDIterOpFlagsKind,
  50  )
  51  
  52  from numpy._typing import (
  53      # Shapes
  54      _ShapeLike,
  55  
  56      # DTypes
  57      DTypeLike,
  58      _DTypeLike,
  59  
  60      # Arrays
  61      NDArray,
  62      ArrayLike,
  63      _ArrayLike,
  64      _SupportsArrayFunc,
  65      _NestedSequence,
  66      _ArrayLikeBool_co,
  67      _ArrayLikeUInt_co,
  68      _ArrayLikeInt_co,
  69      _ArrayLikeFloat_co,
  70      _ArrayLikeComplex_co,
  71      _ArrayLikeTD64_co,
  72      _ArrayLikeDT64_co,
  73      _ArrayLikeObject_co,
  74      _ArrayLikeStr_co,
  75      _ArrayLikeBytes_co,
  76      _ScalarLike_co,
  77      _IntLike_co,
  78      _FloatLike_co,
  79      _TD64Like_co,
  80  )
  81  
  82  _T_co = TypeVar("_T_co", covariant=True)
  83  _T_contra = TypeVar("_T_contra", contravariant=True)
  84  _SCT = TypeVar("_SCT", bound=generic)
  85  _ArrayType = TypeVar("_ArrayType", bound=NDArray[Any])
  86  
  87  # Valid time units
  88  _UnitKind = L[
  89      "Y",
  90      "M",
  91      "D",
  92      "h",
  93      "m",
  94      "s",
  95      "ms",
  96      "us", "μs",
  97      "ns",
  98      "ps",
  99      "fs",
 100      "as",
 101  ]
 102  _RollKind = L[  # `raise` is deliberately excluded
 103      "nat",
 104      "forward",
 105      "following",
 106      "backward",
 107      "preceding",
 108      "modifiedfollowing",
 109      "modifiedpreceding",
 110  ]
 111  
 112  class _SupportsLenAndGetItem(Protocol[_T_contra, _T_co]):
 113      def __len__(self) -> int: ...
 114      def __getitem__(self, key: _T_contra, /) -> _T_co: ...
 115  
 116  __all__: list[str]
 117  
 118  ALLOW_THREADS: Final[int]  # 0 or 1 (system-specific)
 119  BUFSIZE: L[8192]
 120  CLIP: L[0]
 121  WRAP: L[1]
 122  RAISE: L[2]
 123  MAXDIMS: L[32]
 124  MAY_SHARE_BOUNDS: L[0]
 125  MAY_SHARE_EXACT: L[-1]
 126  tracemalloc_domain: L[389047]
 127  
 128  @overload
 129  def empty_like(
 130      prototype: _ArrayType,
 131      dtype: None = ...,
 132      order: _OrderKACF = ...,
 133      subok: bool = ...,
 134      shape: None | _ShapeLike = ...,
 135  ) -> _ArrayType: ...
 136  @overload
 137  def empty_like(
 138      prototype: _ArrayLike[_SCT],
 139      dtype: None = ...,
 140      order: _OrderKACF = ...,
 141      subok: bool = ...,
 142      shape: None | _ShapeLike = ...,
 143  ) -> NDArray[_SCT]: ...
 144  @overload
 145  def empty_like(
 146      prototype: object,
 147      dtype: None = ...,
 148      order: _OrderKACF = ...,
 149      subok: bool = ...,
 150      shape: None | _ShapeLike = ...,
 151  ) -> NDArray[Any]: ...
 152  @overload
 153  def empty_like(
 154      prototype: Any,
 155      dtype: _DTypeLike[_SCT],
 156      order: _OrderKACF = ...,
 157      subok: bool = ...,
 158      shape: None | _ShapeLike = ...,
 159  ) -> NDArray[_SCT]: ...
 160  @overload
 161  def empty_like(
 162      prototype: Any,
 163      dtype: DTypeLike,
 164      order: _OrderKACF = ...,
 165      subok: bool = ...,
 166      shape: None | _ShapeLike = ...,
 167  ) -> NDArray[Any]: ...
 168  
 169  @overload
 170  def array(
 171      object: _ArrayType,
 172      dtype: None = ...,
 173      *,
 174      copy: bool | _CopyMode = ...,
 175      order: _OrderKACF = ...,
 176      subok: L[True],
 177      ndmin: int = ...,
 178      like: None | _SupportsArrayFunc = ...,
 179  ) -> _ArrayType: ...
 180  @overload
 181  def array(
 182      object: _ArrayLike[_SCT],
 183      dtype: None = ...,
 184      *,
 185      copy: bool | _CopyMode = ...,
 186      order: _OrderKACF = ...,
 187      subok: bool = ...,
 188      ndmin: int = ...,
 189      like: None | _SupportsArrayFunc = ...,
 190  ) -> NDArray[_SCT]: ...
 191  @overload
 192  def array(
 193      object: object,
 194      dtype: None = ...,
 195      *,
 196      copy: bool | _CopyMode = ...,
 197      order: _OrderKACF = ...,
 198      subok: bool = ...,
 199      ndmin: int = ...,
 200      like: None | _SupportsArrayFunc = ...,
 201  ) -> NDArray[Any]: ...
 202  @overload
 203  def array(
 204      object: Any,
 205      dtype: _DTypeLike[_SCT],
 206      *,
 207      copy: bool | _CopyMode = ...,
 208      order: _OrderKACF = ...,
 209      subok: bool = ...,
 210      ndmin: int = ...,
 211      like: None | _SupportsArrayFunc = ...,
 212  ) -> NDArray[_SCT]: ...
 213  @overload
 214  def array(
 215      object: Any,
 216      dtype: DTypeLike,
 217      *,
 218      copy: bool | _CopyMode = ...,
 219      order: _OrderKACF = ...,
 220      subok: bool = ...,
 221      ndmin: int = ...,
 222      like: None | _SupportsArrayFunc = ...,
 223  ) -> NDArray[Any]: ...
 224  
 225  @overload
 226  def zeros(
 227      shape: _ShapeLike,
 228      dtype: None = ...,
 229      order: _OrderCF = ...,
 230      *,
 231      like: None | _SupportsArrayFunc = ...,
 232  ) -> NDArray[float64]: ...
 233  @overload
 234  def zeros(
 235      shape: _ShapeLike,
 236      dtype: _DTypeLike[_SCT],
 237      order: _OrderCF = ...,
 238      *,
 239      like: None | _SupportsArrayFunc = ...,
 240  ) -> NDArray[_SCT]: ...
 241  @overload
 242  def zeros(
 243      shape: _ShapeLike,
 244      dtype: DTypeLike,
 245      order: _OrderCF = ...,
 246      *,
 247      like: None | _SupportsArrayFunc = ...,
 248  ) -> NDArray[Any]: ...
 249  
 250  @overload
 251  def empty(
 252      shape: _ShapeLike,
 253      dtype: None = ...,
 254      order: _OrderCF = ...,
 255      *,
 256      like: None | _SupportsArrayFunc = ...,
 257  ) -> NDArray[float64]: ...
 258  @overload
 259  def empty(
 260      shape: _ShapeLike,
 261      dtype: _DTypeLike[_SCT],
 262      order: _OrderCF = ...,
 263      *,
 264      like: None | _SupportsArrayFunc = ...,
 265  ) -> NDArray[_SCT]: ...
 266  @overload
 267  def empty(
 268      shape: _ShapeLike,
 269      dtype: DTypeLike,
 270      order: _OrderCF = ...,
 271      *,
 272      like: None | _SupportsArrayFunc = ...,
 273  ) -> NDArray[Any]: ...
 274  
 275  @overload
 276  def unravel_index(  # type: ignore[misc]
 277      indices: _IntLike_co,
 278      shape: _ShapeLike,
 279      order: _OrderCF = ...,
 280  ) -> tuple[intp, ...]: ...
 281  @overload
 282  def unravel_index(
 283      indices: _ArrayLikeInt_co,
 284      shape: _ShapeLike,
 285      order: _OrderCF = ...,
 286  ) -> tuple[NDArray[intp], ...]: ...
 287  
 288  @overload
 289  def ravel_multi_index(  # type: ignore[misc]
 290      multi_index: Sequence[_IntLike_co],
 291      dims: Sequence[SupportsIndex],
 292      mode: _ModeKind | tuple[_ModeKind, ...] = ...,
 293      order: _OrderCF = ...,
 294  ) -> intp: ...
 295  @overload
 296  def ravel_multi_index(
 297      multi_index: Sequence[_ArrayLikeInt_co],
 298      dims: Sequence[SupportsIndex],
 299      mode: _ModeKind | tuple[_ModeKind, ...] = ...,
 300      order: _OrderCF = ...,
 301  ) -> NDArray[intp]: ...
 302  
 303  # NOTE: Allow any sequence of array-like objects
 304  @overload
 305  def concatenate(  # type: ignore[misc]
 306      arrays: _ArrayLike[_SCT],
 307      /,
 308      axis: None | SupportsIndex = ...,
 309      out: None = ...,
 310      *,
 311      dtype: None = ...,
 312      casting: None | _CastingKind = ...
 313  ) -> NDArray[_SCT]: ...
 314  @overload
 315  def concatenate(  # type: ignore[misc]
 316      arrays: _SupportsLenAndGetItem[int, ArrayLike],
 317      /,
 318      axis: None | SupportsIndex = ...,
 319      out: None = ...,
 320      *,
 321      dtype: None = ...,
 322      casting: None | _CastingKind = ...
 323  ) -> NDArray[Any]: ...
 324  @overload
 325  def concatenate(  # type: ignore[misc]
 326      arrays: _SupportsLenAndGetItem[int, ArrayLike],
 327      /,
 328      axis: None | SupportsIndex = ...,
 329      out: None = ...,
 330      *,
 331      dtype: _DTypeLike[_SCT],
 332      casting: None | _CastingKind = ...
 333  ) -> NDArray[_SCT]: ...
 334  @overload
 335  def concatenate(  # type: ignore[misc]
 336      arrays: _SupportsLenAndGetItem[int, ArrayLike],
 337      /,
 338      axis: None | SupportsIndex = ...,
 339      out: None = ...,
 340      *,
 341      dtype: DTypeLike,
 342      casting: None | _CastingKind = ...
 343  ) -> NDArray[Any]: ...
 344  @overload
 345  def concatenate(
 346      arrays: _SupportsLenAndGetItem[int, ArrayLike],
 347      /,
 348      axis: None | SupportsIndex = ...,
 349      out: _ArrayType = ...,
 350      *,
 351      dtype: DTypeLike = ...,
 352      casting: None | _CastingKind = ...
 353  ) -> _ArrayType: ...
 354  
 355  def inner(
 356      a: ArrayLike,
 357      b: ArrayLike,
 358      /,
 359  ) -> Any: ...
 360  
 361  @overload
 362  def where(
 363      condition: ArrayLike,
 364      /,
 365  ) -> tuple[NDArray[intp], ...]: ...
 366  @overload
 367  def where(
 368      condition: ArrayLike,
 369      x: ArrayLike,
 370      y: ArrayLike,
 371      /,
 372  ) -> NDArray[Any]: ...
 373  
 374  def lexsort(
 375      keys: ArrayLike,
 376      axis: None | SupportsIndex = ...,
 377  ) -> Any: ...
 378  
 379  def can_cast(
 380      from_: ArrayLike | DTypeLike,
 381      to: DTypeLike,
 382      casting: None | _CastingKind = ...,
 383  ) -> bool: ...
 384  
 385  def min_scalar_type(
 386      a: ArrayLike, /,
 387  ) -> dtype[Any]: ...
 388  
 389  def result_type(
 390      *arrays_and_dtypes: ArrayLike | DTypeLike,
 391  ) -> dtype[Any]: ...
 392  
 393  @overload
 394  def dot(a: ArrayLike, b: ArrayLike, out: None = ...) -> Any: ...
 395  @overload
 396  def dot(a: ArrayLike, b: ArrayLike, out: _ArrayType) -> _ArrayType: ...
 397  
 398  @overload
 399  def vdot(a: _ArrayLikeBool_co, b: _ArrayLikeBool_co, /) -> bool_: ...  # type: ignore[misc]
 400  @overload
 401  def vdot(a: _ArrayLikeUInt_co, b: _ArrayLikeUInt_co, /) -> unsignedinteger[Any]: ...  # type: ignore[misc]
 402  @overload
 403  def vdot(a: _ArrayLikeInt_co, b: _ArrayLikeInt_co, /) -> signedinteger[Any]: ... # type: ignore[misc]
 404  @overload
 405  def vdot(a: _ArrayLikeFloat_co, b: _ArrayLikeFloat_co, /) -> floating[Any]: ...  # type: ignore[misc]
 406  @overload
 407  def vdot(a: _ArrayLikeComplex_co, b: _ArrayLikeComplex_co, /) -> complexfloating[Any, Any]: ...  # type: ignore[misc]
 408  @overload
 409  def vdot(a: _ArrayLikeTD64_co, b: _ArrayLikeTD64_co, /) -> timedelta64: ...
 410  @overload
 411  def vdot(a: _ArrayLikeObject_co, b: Any, /) -> Any: ...
 412  @overload
 413  def vdot(a: Any, b: _ArrayLikeObject_co, /) -> Any: ...
 414  
 415  def bincount(
 416      x: ArrayLike,
 417      /,
 418      weights: None | ArrayLike = ...,
 419      minlength: SupportsIndex = ...,
 420  ) -> NDArray[intp]: ...
 421  
 422  def copyto(
 423      dst: NDArray[Any],
 424      src: ArrayLike,
 425      casting: None | _CastingKind = ...,
 426      where: None | _ArrayLikeBool_co = ...,
 427  ) -> None: ...
 428  
 429  def putmask(
 430      a: NDArray[Any],
 431      mask: _ArrayLikeBool_co,
 432      values: ArrayLike,
 433  ) -> None: ...
 434  
 435  def packbits(
 436      a: _ArrayLikeInt_co,
 437      /,
 438      axis: None | SupportsIndex = ...,
 439      bitorder: L["big", "little"] = ...,
 440  ) -> NDArray[uint8]: ...
 441  
 442  def unpackbits(
 443      a: _ArrayLike[uint8],
 444      /,
 445      axis: None | SupportsIndex = ...,
 446      count: None | SupportsIndex = ...,
 447      bitorder: L["big", "little"] = ...,
 448  ) -> NDArray[uint8]: ...
 449  
 450  def shares_memory(
 451      a: object,
 452      b: object,
 453      /,
 454      max_work: None | int = ...,
 455  ) -> bool: ...
 456  
 457  def may_share_memory(
 458      a: object,
 459      b: object,
 460      /,
 461      max_work: None | int = ...,
 462  ) -> bool: ...
 463  
 464  @overload
 465  def asarray(
 466      a: _ArrayLike[_SCT],
 467      dtype: None = ...,
 468      order: _OrderKACF = ...,
 469      *,
 470      like: None | _SupportsArrayFunc = ...,
 471  ) -> NDArray[_SCT]: ...
 472  @overload
 473  def asarray(
 474      a: object,
 475      dtype: None = ...,
 476      order: _OrderKACF = ...,
 477      *,
 478      like: None | _SupportsArrayFunc = ...,
 479  ) -> NDArray[Any]: ...
 480  @overload
 481  def asarray(
 482      a: Any,
 483      dtype: _DTypeLike[_SCT],
 484      order: _OrderKACF = ...,
 485      *,
 486      like: None | _SupportsArrayFunc = ...,
 487  ) -> NDArray[_SCT]: ...
 488  @overload
 489  def asarray(
 490      a: Any,
 491      dtype: DTypeLike,
 492      order: _OrderKACF = ...,
 493      *,
 494      like: None | _SupportsArrayFunc = ...,
 495  ) -> NDArray[Any]: ...
 496  
 497  @overload
 498  def asanyarray(
 499      a: _ArrayType,  # Preserve subclass-information
 500      dtype: None = ...,
 501      order: _OrderKACF = ...,
 502      *,
 503      like: None | _SupportsArrayFunc = ...,
 504  ) -> _ArrayType: ...
 505  @overload
 506  def asanyarray(
 507      a: _ArrayLike[_SCT],
 508      dtype: None = ...,
 509      order: _OrderKACF = ...,
 510      *,
 511      like: None | _SupportsArrayFunc = ...,
 512  ) -> NDArray[_SCT]: ...
 513  @overload
 514  def asanyarray(
 515      a: object,
 516      dtype: None = ...,
 517      order: _OrderKACF = ...,
 518      *,
 519      like: None | _SupportsArrayFunc = ...,
 520  ) -> NDArray[Any]: ...
 521  @overload
 522  def asanyarray(
 523      a: Any,
 524      dtype: _DTypeLike[_SCT],
 525      order: _OrderKACF = ...,
 526      *,
 527      like: None | _SupportsArrayFunc = ...,
 528  ) -> NDArray[_SCT]: ...
 529  @overload
 530  def asanyarray(
 531      a: Any,
 532      dtype: DTypeLike,
 533      order: _OrderKACF = ...,
 534      *,
 535      like: None | _SupportsArrayFunc = ...,
 536  ) -> NDArray[Any]: ...
 537  
 538  @overload
 539  def ascontiguousarray(
 540      a: _ArrayLike[_SCT],
 541      dtype: None = ...,
 542      *,
 543      like: None | _SupportsArrayFunc = ...,
 544  ) -> NDArray[_SCT]: ...
 545  @overload
 546  def ascontiguousarray(
 547      a: object,
 548      dtype: None = ...,
 549      *,
 550      like: None | _SupportsArrayFunc = ...,
 551  ) -> NDArray[Any]: ...
 552  @overload
 553  def ascontiguousarray(
 554      a: Any,
 555      dtype: _DTypeLike[_SCT],
 556      *,
 557      like: None | _SupportsArrayFunc = ...,
 558  ) -> NDArray[_SCT]: ...
 559  @overload
 560  def ascontiguousarray(
 561      a: Any,
 562      dtype: DTypeLike,
 563      *,
 564      like: None | _SupportsArrayFunc = ...,
 565  ) -> NDArray[Any]: ...
 566  
 567  @overload
 568  def asfortranarray(
 569      a: _ArrayLike[_SCT],
 570      dtype: None = ...,
 571      *,
 572      like: None | _SupportsArrayFunc = ...,
 573  ) -> NDArray[_SCT]: ...
 574  @overload
 575  def asfortranarray(
 576      a: object,
 577      dtype: None = ...,
 578      *,
 579      like: None | _SupportsArrayFunc = ...,
 580  ) -> NDArray[Any]: ...
 581  @overload
 582  def asfortranarray(
 583      a: Any,
 584      dtype: _DTypeLike[_SCT],
 585      *,
 586      like: None | _SupportsArrayFunc = ...,
 587  ) -> NDArray[_SCT]: ...
 588  @overload
 589  def asfortranarray(
 590      a: Any,
 591      dtype: DTypeLike,
 592      *,
 593      like: None | _SupportsArrayFunc = ...,
 594  ) -> NDArray[Any]: ...
 595  
 596  # In practice `list[Any]` is list with an int, int and a valid
 597  # `np.seterrcall()` object
 598  def geterrobj() -> list[Any]: ...
 599  def seterrobj(errobj: list[Any], /) -> None: ...
 600  
 601  def promote_types(__type1: DTypeLike, __type2: DTypeLike) -> dtype[Any]: ...
 602  
 603  # `sep` is a de facto mandatory argument, as its default value is deprecated
 604  @overload
 605  def fromstring(
 606      string: str | bytes,
 607      dtype: None = ...,
 608      count: SupportsIndex = ...,
 609      *,
 610      sep: str,
 611      like: None | _SupportsArrayFunc = ...,
 612  ) -> NDArray[float64]: ...
 613  @overload
 614  def fromstring(
 615      string: str | bytes,
 616      dtype: _DTypeLike[_SCT],
 617      count: SupportsIndex = ...,
 618      *,
 619      sep: str,
 620      like: None | _SupportsArrayFunc = ...,
 621  ) -> NDArray[_SCT]: ...
 622  @overload
 623  def fromstring(
 624      string: str | bytes,
 625      dtype: DTypeLike,
 626      count: SupportsIndex = ...,
 627      *,
 628      sep: str,
 629      like: None | _SupportsArrayFunc = ...,
 630  ) -> NDArray[Any]: ...
 631  
 632  def frompyfunc(
 633      func: Callable[..., Any], /,
 634      nin: SupportsIndex,
 635      nout: SupportsIndex,
 636      *,
 637      identity: Any = ...,
 638  ) -> ufunc: ...
 639  
 640  @overload
 641  def fromfile(
 642      file: str | bytes | os.PathLike[Any] | _IOProtocol,
 643      dtype: None = ...,
 644      count: SupportsIndex = ...,
 645      sep: str = ...,
 646      offset: SupportsIndex = ...,
 647      *,
 648      like: None | _SupportsArrayFunc = ...,
 649  ) -> NDArray[float64]: ...
 650  @overload
 651  def fromfile(
 652      file: str | bytes | os.PathLike[Any] | _IOProtocol,
 653      dtype: _DTypeLike[_SCT],
 654      count: SupportsIndex = ...,
 655      sep: str = ...,
 656      offset: SupportsIndex = ...,
 657      *,
 658      like: None | _SupportsArrayFunc = ...,
 659  ) -> NDArray[_SCT]: ...
 660  @overload
 661  def fromfile(
 662      file: str | bytes | os.PathLike[Any] | _IOProtocol,
 663      dtype: DTypeLike,
 664      count: SupportsIndex = ...,
 665      sep: str = ...,
 666      offset: SupportsIndex = ...,
 667      *,
 668      like: None | _SupportsArrayFunc = ...,
 669  ) -> NDArray[Any]: ...
 670  
 671  @overload
 672  def fromiter(
 673      iter: Iterable[Any],
 674      dtype: _DTypeLike[_SCT],
 675      count: SupportsIndex = ...,
 676      *,
 677      like: None | _SupportsArrayFunc = ...,
 678  ) -> NDArray[_SCT]: ...
 679  @overload
 680  def fromiter(
 681      iter: Iterable[Any],
 682      dtype: DTypeLike,
 683      count: SupportsIndex = ...,
 684      *,
 685      like: None | _SupportsArrayFunc = ...,
 686  ) -> NDArray[Any]: ...
 687  
 688  @overload
 689  def frombuffer(
 690      buffer: _SupportsBuffer,
 691      dtype: None = ...,
 692      count: SupportsIndex = ...,
 693      offset: SupportsIndex = ...,
 694      *,
 695      like: None | _SupportsArrayFunc = ...,
 696  ) -> NDArray[float64]: ...
 697  @overload
 698  def frombuffer(
 699      buffer: _SupportsBuffer,
 700      dtype: _DTypeLike[_SCT],
 701      count: SupportsIndex = ...,
 702      offset: SupportsIndex = ...,
 703      *,
 704      like: None | _SupportsArrayFunc = ...,
 705  ) -> NDArray[_SCT]: ...
 706  @overload
 707  def frombuffer(
 708      buffer: _SupportsBuffer,
 709      dtype: DTypeLike,
 710      count: SupportsIndex = ...,
 711      offset: SupportsIndex = ...,
 712      *,
 713      like: None | _SupportsArrayFunc = ...,
 714  ) -> NDArray[Any]: ...
 715  
 716  @overload
 717  def arange(  # type: ignore[misc]
 718      stop: _IntLike_co,
 719      /, *,
 720      dtype: None = ...,
 721      like: None | _SupportsArrayFunc = ...,
 722  ) -> NDArray[signedinteger[Any]]: ...
 723  @overload
 724  def arange(  # type: ignore[misc]
 725      start: _IntLike_co,
 726      stop: _IntLike_co,
 727      step: _IntLike_co = ...,
 728      dtype: None = ...,
 729      *,
 730      like: None | _SupportsArrayFunc = ...,
 731  ) -> NDArray[signedinteger[Any]]: ...
 732  @overload
 733  def arange(  # type: ignore[misc]
 734      stop: _FloatLike_co,
 735      /, *,
 736      dtype: None = ...,
 737      like: None | _SupportsArrayFunc = ...,
 738  ) -> NDArray[floating[Any]]: ...
 739  @overload
 740  def arange(  # type: ignore[misc]
 741      start: _FloatLike_co,
 742      stop: _FloatLike_co,
 743      step: _FloatLike_co = ...,
 744      dtype: None = ...,
 745      *,
 746      like: None | _SupportsArrayFunc = ...,
 747  ) -> NDArray[floating[Any]]: ...
 748  @overload
 749  def arange(
 750      stop: _TD64Like_co,
 751      /, *,
 752      dtype: None = ...,
 753      like: None | _SupportsArrayFunc = ...,
 754  ) -> NDArray[timedelta64]: ...
 755  @overload
 756  def arange(
 757      start: _TD64Like_co,
 758      stop: _TD64Like_co,
 759      step: _TD64Like_co = ...,
 760      dtype: None = ...,
 761      *,
 762      like: None | _SupportsArrayFunc = ...,
 763  ) -> NDArray[timedelta64]: ...
 764  @overload
 765  def arange(  # both start and stop must always be specified for datetime64
 766      start: datetime64,
 767      stop: datetime64,
 768      step: datetime64 = ...,
 769      dtype: None = ...,
 770      *,
 771      like: None | _SupportsArrayFunc = ...,
 772  ) -> NDArray[datetime64]: ...
 773  @overload
 774  def arange(
 775      stop: Any,
 776      /, *,
 777      dtype: _DTypeLike[_SCT],
 778      like: None | _SupportsArrayFunc = ...,
 779  ) -> NDArray[_SCT]: ...
 780  @overload
 781  def arange(
 782      start: Any,
 783      stop: Any,
 784      step: Any = ...,
 785      dtype: _DTypeLike[_SCT] = ...,
 786      *,
 787      like: None | _SupportsArrayFunc = ...,
 788  ) -> NDArray[_SCT]: ...
 789  @overload
 790  def arange(
 791      stop: Any, /,
 792      *,
 793      dtype: DTypeLike,
 794      like: None | _SupportsArrayFunc = ...,
 795  ) -> NDArray[Any]: ...
 796  @overload
 797  def arange(
 798      start: Any,
 799      stop: Any,
 800      step: Any = ...,
 801      dtype: DTypeLike = ...,
 802      *,
 803      like: None | _SupportsArrayFunc = ...,
 804  ) -> NDArray[Any]: ...
 805  
 806  def datetime_data(
 807      dtype: str | _DTypeLike[datetime64] | _DTypeLike[timedelta64], /,
 808  ) -> tuple[str, int]: ...
 809  
 810  # The datetime functions perform unsafe casts to `datetime64[D]`,
 811  # so a lot of different argument types are allowed here
 812  
 813  @overload
 814  def busday_count(  # type: ignore[misc]
 815      begindates: _ScalarLike_co | dt.date,
 816      enddates: _ScalarLike_co | dt.date,
 817      weekmask: ArrayLike = ...,
 818      holidays: None | ArrayLike | dt.date | _NestedSequence[dt.date] = ...,
 819      busdaycal: None | busdaycalendar = ...,
 820      out: None = ...,
 821  ) -> int_: ...
 822  @overload
 823  def busday_count(  # type: ignore[misc]
 824      begindates: ArrayLike | dt.date | _NestedSequence[dt.date],
 825      enddates: ArrayLike | dt.date | _NestedSequence[dt.date],
 826      weekmask: ArrayLike = ...,
 827      holidays: None | ArrayLike | dt.date | _NestedSequence[dt.date] = ...,
 828      busdaycal: None | busdaycalendar = ...,
 829      out: None = ...,
 830  ) -> NDArray[int_]: ...
 831  @overload
 832  def busday_count(
 833      begindates: ArrayLike | dt.date | _NestedSequence[dt.date],
 834      enddates: ArrayLike | dt.date | _NestedSequence[dt.date],
 835      weekmask: ArrayLike = ...,
 836      holidays: None | ArrayLike | dt.date | _NestedSequence[dt.date] = ...,
 837      busdaycal: None | busdaycalendar = ...,
 838      out: _ArrayType = ...,
 839  ) -> _ArrayType: ...
 840  
 841  # `roll="raise"` is (more or less?) equivalent to `casting="safe"`
 842  @overload
 843  def busday_offset(  # type: ignore[misc]
 844      dates: datetime64 | dt.date,
 845      offsets: _TD64Like_co | dt.timedelta,
 846      roll: L["raise"] = ...,
 847      weekmask: ArrayLike = ...,
 848      holidays: None | ArrayLike | dt.date | _NestedSequence[dt.date] = ...,
 849      busdaycal: None | busdaycalendar = ...,
 850      out: None = ...,
 851  ) -> datetime64: ...
 852  @overload
 853  def busday_offset(  # type: ignore[misc]
 854      dates: _ArrayLike[datetime64] | dt.date | _NestedSequence[dt.date],
 855      offsets: _ArrayLikeTD64_co | dt.timedelta | _NestedSequence[dt.timedelta],
 856      roll: L["raise"] = ...,
 857      weekmask: ArrayLike = ...,
 858      holidays: None | ArrayLike | dt.date | _NestedSequence[dt.date] = ...,
 859      busdaycal: None | busdaycalendar = ...,
 860      out: None = ...,
 861  ) -> NDArray[datetime64]: ...
 862  @overload
 863  def busday_offset(  # type: ignore[misc]
 864      dates: _ArrayLike[datetime64] | dt.date | _NestedSequence[dt.date],
 865      offsets: _ArrayLikeTD64_co | dt.timedelta | _NestedSequence[dt.timedelta],
 866      roll: L["raise"] = ...,
 867      weekmask: ArrayLike = ...,
 868      holidays: None | ArrayLike | dt.date | _NestedSequence[dt.date] = ...,
 869      busdaycal: None | busdaycalendar = ...,
 870      out: _ArrayType = ...,
 871  ) -> _ArrayType: ...
 872  @overload
 873  def busday_offset(  # type: ignore[misc]
 874      dates: _ScalarLike_co | dt.date,
 875      offsets: _ScalarLike_co | dt.timedelta,
 876      roll: _RollKind,
 877      weekmask: ArrayLike = ...,
 878      holidays: None | ArrayLike | dt.date | _NestedSequence[dt.date] = ...,
 879      busdaycal: None | busdaycalendar = ...,
 880      out: None = ...,
 881  ) -> datetime64: ...
 882  @overload
 883  def busday_offset(  # type: ignore[misc]
 884      dates: ArrayLike | dt.date | _NestedSequence[dt.date],
 885      offsets: ArrayLike | dt.timedelta | _NestedSequence[dt.timedelta],
 886      roll: _RollKind,
 887      weekmask: ArrayLike = ...,
 888      holidays: None | ArrayLike | dt.date | _NestedSequence[dt.date] = ...,
 889      busdaycal: None | busdaycalendar = ...,
 890      out: None = ...,
 891  ) -> NDArray[datetime64]: ...
 892  @overload
 893  def busday_offset(
 894      dates: ArrayLike | dt.date | _NestedSequence[dt.date],
 895      offsets: ArrayLike | dt.timedelta | _NestedSequence[dt.timedelta],
 896      roll: _RollKind,
 897      weekmask: ArrayLike = ...,
 898      holidays: None | ArrayLike | dt.date | _NestedSequence[dt.date] = ...,
 899      busdaycal: None | busdaycalendar = ...,
 900      out: _ArrayType = ...,
 901  ) -> _ArrayType: ...
 902  
 903  @overload
 904  def is_busday(  # type: ignore[misc]
 905      dates: _ScalarLike_co | dt.date,
 906      weekmask: ArrayLike = ...,
 907      holidays: None | ArrayLike | dt.date | _NestedSequence[dt.date] = ...,
 908      busdaycal: None | busdaycalendar = ...,
 909      out: None = ...,
 910  ) -> bool_: ...
 911  @overload
 912  def is_busday(  # type: ignore[misc]
 913      dates: ArrayLike | _NestedSequence[dt.date],
 914      weekmask: ArrayLike = ...,
 915      holidays: None | ArrayLike | dt.date | _NestedSequence[dt.date] = ...,
 916      busdaycal: None | busdaycalendar = ...,
 917      out: None = ...,
 918  ) -> NDArray[bool_]: ...
 919  @overload
 920  def is_busday(
 921      dates: ArrayLike | _NestedSequence[dt.date],
 922      weekmask: ArrayLike = ...,
 923      holidays: None | ArrayLike | dt.date | _NestedSequence[dt.date] = ...,
 924      busdaycal: None | busdaycalendar = ...,
 925      out: _ArrayType = ...,
 926  ) -> _ArrayType: ...
 927  
 928  @overload
 929  def datetime_as_string(  # type: ignore[misc]
 930      arr: datetime64 | dt.date,
 931      unit: None | L["auto"] | _UnitKind = ...,
 932      timezone: L["naive", "UTC", "local"] | dt.tzinfo = ...,
 933      casting: _CastingKind = ...,
 934  ) -> str_: ...
 935  @overload
 936  def datetime_as_string(
 937      arr: _ArrayLikeDT64_co | _NestedSequence[dt.date],
 938      unit: None | L["auto"] | _UnitKind = ...,
 939      timezone: L["naive", "UTC", "local"] | dt.tzinfo = ...,
 940      casting: _CastingKind = ...,
 941  ) -> NDArray[str_]: ...
 942  
 943  @overload
 944  def compare_chararrays(
 945      a1: _ArrayLikeStr_co,
 946      a2: _ArrayLikeStr_co,
 947      cmp: L["<", "<=", "==", ">=", ">", "!="],
 948      rstrip: bool,
 949  ) -> NDArray[bool_]: ...
 950  @overload
 951  def compare_chararrays(
 952      a1: _ArrayLikeBytes_co,
 953      a2: _ArrayLikeBytes_co,
 954      cmp: L["<", "<=", "==", ">=", ">", "!="],
 955      rstrip: bool,
 956  ) -> NDArray[bool_]: ...
 957  
 958  def add_docstring(obj: Callable[..., Any], docstring: str, /) -> None: ...
 959  
 960  _GetItemKeys = L[
 961      "C", "CONTIGUOUS", "C_CONTIGUOUS",
 962      "F", "FORTRAN", "F_CONTIGUOUS",
 963      "W", "WRITEABLE",
 964      "B", "BEHAVED",
 965      "O", "OWNDATA",
 966      "A", "ALIGNED",
 967      "X", "WRITEBACKIFCOPY",
 968      "CA", "CARRAY",
 969      "FA", "FARRAY",
 970      "FNC",
 971      "FORC",
 972  ]
 973  _SetItemKeys = L[
 974      "A", "ALIGNED",
 975      "W", "WRITEABLE",
 976      "X", "WRITEBACKIFCOPY",
 977  ]
 978  
 979  @final
 980  class flagsobj:
 981      __hash__: ClassVar[None]  # type: ignore[assignment]
 982      aligned: bool
 983      # NOTE: deprecated
 984      # updateifcopy: bool
 985      writeable: bool
 986      writebackifcopy: bool
 987      @property
 988      def behaved(self) -> bool: ...
 989      @property
 990      def c_contiguous(self) -> bool: ...
 991      @property
 992      def carray(self) -> bool: ...
 993      @property
 994      def contiguous(self) -> bool: ...
 995      @property
 996      def f_contiguous(self) -> bool: ...
 997      @property
 998      def farray(self) -> bool: ...
 999      @property
1000      def fnc(self) -> bool: ...
1001      @property
1002      def forc(self) -> bool: ...
1003      @property
1004      def fortran(self) -> bool: ...
1005      @property
1006      def num(self) -> int: ...
1007      @property
1008      def owndata(self) -> bool: ...
1009      def __getitem__(self, key: _GetItemKeys) -> bool: ...
1010      def __setitem__(self, key: _SetItemKeys, value: bool) -> None: ...
1011  
1012  def nested_iters(
1013      op: ArrayLike | Sequence[ArrayLike],
1014      axes: Sequence[Sequence[SupportsIndex]],
1015      flags: None | Sequence[_NDIterFlagsKind] = ...,
1016      op_flags: None | Sequence[Sequence[_NDIterOpFlagsKind]] = ...,
1017      op_dtypes: DTypeLike | Sequence[DTypeLike] = ...,
1018      order: _OrderKACF = ...,
1019      casting: _CastingKind = ...,
1020      buffersize: SupportsIndex = ...,
1021  ) -> tuple[nditer, ...]: ...