files: from __future__ import annotations
  
  from ._types import Optional, Tuple, Union, array, device, dtype
  
  import numpy as np
  
  def arange(start: Union[int, float], /, *, stop: Optional[Union[int, float]] = None, step: Union[int, float] = 1, dtype: Optional[dtype] = None, device: Optional[device] = None) -> array:
      """
      Array API compatible wrapper for :py:func:`np.arange <numpy.arange>`.
  
      See its docstring for more information.
      """
      if device is not None:
          # Note: Device support is not yet implemented on ndarray
          raise NotImplementedError("Device support is not yet implemented")
      return np.arange(start, stop=stop, step=step, dtype=dtype)
  
  def empty(shape: Union[int, Tuple[int, ...]], /, *, dtype: Optional[dtype] = None, device: Optional[device] = None) -> array:
      """
      Array API compatible wrapper for :py:func:`np.empty <numpy.empty>`.
  
      See its docstring for more information.
      """
      if device is not None:
          # Note: Device support is not yet implemented on ndarray
          raise NotImplementedError("Device support is not yet implemented")
      return np.empty(shape, dtype=dtype)
  
  def empty_like(x: array, /, *, dtype: Optional[dtype] = None, device: Optional[device] = None) -> array:
      """
      Array API compatible wrapper for :py:func:`np.empty_like <numpy.empty_like>`.
  
      See its docstring for more information.
      """
      if device is not None:
          # Note: Device support is not yet implemented on ndarray
          raise NotImplementedError("Device support is not yet implemented")
      return np.empty_like._implementation(x, dtype=dtype)
  
  def eye(N: int, /, *, M: Optional[int] = None, k: Optional[int] = 0, dtype: Optional[dtype] = None, device: Optional[device] = None) -> array
  
  [... the rest is omitted ...]
files: numpy/_array_api/_creation_functions.py
files: from __future__ import annotations
  
  from ._types import Optional, Tuple, Union, array, device, dtype
  
  import numpy as np
  
  def arange(start: Union[int, float], /, *, stop: Optional[Union[int, float]] = None, step: Union[int, float] = 1, dtype: Optional[dtype] = None, device: Optional[device] = None) -> array:
      """
      Array API compatible wrapper for :py:func:`np.arange <numpy.arange>`.
  
      See its docstring for more information.
      """
      if device is not None:
          # Note: Device support is not yet implemented on ndarray
          raise NotImplementedError("Device support is not yet implemented")
      return np.arange(start, stop=stop, step=step, dtype=dtype)
  
  def empty(shape: Union[int, Tuple[int, ...]], /, *, dtype: Optional[dtype] = None, device: Optional[device] = None) -> array:
      """
      Array API compatible wrapper for :py:func:`np.empty <numpy.empty>`.
  
      See its docstring for more information.
      """
      if device is not None:
          # Note: Device support is not yet implemented on ndarray
          raise NotImplementedError("Device support is not yet implemented")
      return np.empty(shape, dtype=dtype)
  
  def empty_like(x: array, /, *, dtype: Optional[dtype] = None, device: Optional[device] = None) -> array:
      """
      Array API compatible wrapper for :py:func:`np.empty_like <numpy.empty_like>`.
  
      See its docstring for more information.
      """
      if device is not None:
          # Note: Device support is not yet implemented on ndarray
          raise NotImplementedError("Device support is not yet implemented")
      return np.empty_like(x, dtype=dtype)
  
  def eye(N: int, /, *, M: Optional[int] = None, k: Optional[int] = 0, dtype: Optional[dtype] = None, device: Optional[device] = None) -> array:
     
  
  [... the rest is omitted ...]
files: numpy/_array_api/_creation_functions.py
files: from __future__ import annotations
  
  from ._types import array
  
  import numpy as np
  
  def abs(x: array, /) -> array:
      """
      Array API compatible wrapper for :py:func:`np.abs <numpy.abs>`.
  
      See its docstring for more information.
      """
      return np.abs(x)
  
  def acos(x: array, /) -> array:
      """
      Array API compatible wrapper for :py:func:`np.arccos <numpy.arccos>`.
  
      See its docstring for more information.
      """
      # Note: the function name is different here
      return np.arccos(x)
  
  def acosh(x: array, /) -> array:
      """
      Array API compatible wrapper for :py:func:`np.arccosh <numpy.arccosh>`.
  
      See its docstring for more information.
      """
      # Note: the function name is different here
      return np.arccosh(x)
  
  def add(x1: array, x2: array, /) -> array:
      """
      Array API compatible wrapper for :py:func:`np.add <numpy.add>`.
  
      See its docstring for more information.
      """
      return np.add(x1, x2)
  
  def asin(x: array, /) -> array:
      """
      Array API compatible wrapper for :py:func:`np.arcsin <numpy.arcsin>`.
  
      See its docstring for more information.
      """
      # Note: the function name is different here
      return np.arcsin(x)
  
  def asinh(x: array, /) -> array:
      """
      Array API compatible wrapper for :py:func:`np.arcsinh <numpy.arcsinh>`.
  
      See its docstring for more information.
      """
      # Note: the function name is different here
      return np.arcsinh(x)
  
  def atan(x: array, /) -> array:
      """
      Array API compatible wrapper for :py:func:`np.arctan <numpy.arctan>`.
  
      See its docstring for more information
  
  [... the rest is omitted ...]
files: numpy/_array_api/_elementwise_functions.py
files: from __future__ import annotations
  
  from ._types import array
  
  import numpy as np
  
  def abs(x: array, /) -> array:
      """
      Array API compatible wrapper for :py:func:`np.abs <numpy.abs>`.
  
      See its docstring for more information.
      """
      return np.abs(x)
  
  def acos(x: array, /) -> array:
      """
      Array API compatible wrapper for :py:func:`np.arccos <numpy.arccos>`.
  
      See its docstring for more information.
      """
      # Note: the function name is different here
      return np.arccos(x)
  
  def acosh(x: array, /) -> array:
      """
      Array API compatible wrapper for :py:func:`np.arccosh <numpy.arccosh>`.
  
      See its docstring for more information.
      """
      # Note: the function name is different here
      return np.arccosh(x)
  
  def add(x1: array, x2: array, /) -> array:
      """
      Array API compatible wrapper for :py:func:`np.add <numpy.add>`.
  
      See its docstring for more information.
      """
      return np.add(x1, x2)
  
  def asin(x: array, /) -> array:
      """
      Array API compatible wrapper for :py:func:`np.arcsin <numpy.arcsin>`.
  
      See its docstring for more information.
      """
      # Note: the function name is different here
      return np.arcsin(x)
  
  def asinh(x: array, /) -> array:
      """
      Array API compatible wrapper for :py:func:`np.arcsinh <numpy.arcsinh>`.
  
      See its docstring for more information.
      """
      # Note: the function name is different here
      return np.arcsinh(x)
  
  def atan(x: array, /) -> array:
      """
      Array API compatible wrapper for :py:func:`np.arctan <numpy.arctan>`.
  
      See its docstring for more information
  
  [... the rest is omitted ...]
files: numpy/_array_api/_elementwise_functions.py
files: from __future__ import annotations
  
  from ._types import Literal, Optional, Tuple, Union, array
  
  import numpy as np
  
  # def cholesky():
  #     """
  #     Array API compatible wrapper for :py:func:`np.cholesky <numpy.cholesky>`.
  #
  #     See its docstring for more information.
  #     """
  #     return np.cholesky()
  
  def cross(x1: array, x2: array, /, *, axis: int = -1) -> array:
      """
      Array API compatible wrapper for :py:func:`np.cross <numpy.cross>`.
  
      See its docstring for more information.
      """
      return np.cross._implementation(x1, x2, axis=axis)
  
  def det(x: array, /) -> array:
      """
      Array API compatible wrapper for :py:func:`np.linalg.det <numpy.linalg.det>`.
  
      See its docstring for more information.
      """
      # Note: this function is being imported from a nondefault namespace
      return np.linalg.det(x)
  
  def diagonal(x: array, /, *, axis1: int = 0, axis2: int = 1, offset: int = 0) -> array:
      """
      Array API compatible wrapper for :py:func:`np.diagonal <numpy.diagonal>`.
  
      See its docstring for more information.
      """
      return np.diagonal._implementation(x, axis1=axis1, axis2=axis2, offset=offset)
  
  # def dot():
  #     """
  #     Array API compatible wrapper for :py:func:`np.dot <numpy.dot>`.
  #
  #     See its docstring for more information.
  #     """
  #     return np.dot()
  #
  # def eig():
  #     """
  #     Array API compatible wrapper for :py:func:`np.eig <numpy.eig>`.
  #
  #     See its docstring for more information.
  #     """
  #     return np.eig()
  #
  # def eigvalsh():
  #     """
  #     Array
  
  [... the rest is omitted ...]
files: numpy/_array_api/_linear_algebra_functions.py
files: from __future__ import annotations
  
  from ._types import Literal, Optional, Tuple, Union, array
  
  import numpy as np
  
  # def cholesky():
  #     """
  #     Array API compatible wrapper for :py:func:`np.cholesky <numpy.cholesky>`.
  #
  #     See its docstring for more information.
  #     """
  #     return np.cholesky()
  
  def cross(x1: array, x2: array, /, *, axis: int = -1) -> array:
      """
      Array API compatible wrapper for :py:func:`np.cross <numpy.cross>`.
  
      See its docstring for more information.
      """
      return np.cross(x1, x2, axis=axis)
  
  def det(x: array, /) -> array:
      """
      Array API compatible wrapper for :py:func:`np.linalg.det <numpy.linalg.det>`.
  
      See its docstring for more information.
      """
      # Note: this function is being imported from a nondefault namespace
      return np.linalg.det(x)
  
  def diagonal(x: array, /, *, axis1: int = 0, axis2: int = 1, offset: int = 0) -> array:
      """
      Array API compatible wrapper for :py:func:`np.diagonal <numpy.diagonal>`.
  
      See its docstring for more information.
      """
      return np.diagonal(x, axis1=axis1, axis2=axis2, offset=offset)
  
  # def dot():
  #     """
  #     Array API compatible wrapper for :py:func:`np.dot <numpy.dot>`.
  #
  #     See its docstring for more information.
  #     """
  #     return np.dot()
  #
  # def eig():
  #     """
  #     Array API compatible wrapper for :py:func:`np.eig <numpy.eig>`.
  #
  #     See its docstring for more information.
  #     """
  #     return np.eig()
  #
  # def eigvalsh():
  #     """
  #     Array API compatible wrapper for
  
  [... the rest is omitted ...]
files: numpy/_array_api/_linear_algebra_functions.py
files: from __future__ import annotations
  
  from ._types import Optional, Tuple, Union, array
  
  import numpy as np
  
  def concat(arrays: Tuple[array], /, *, axis: Optional[int] = 0) -> array:
      """
      Array API compatible wrapper for :py:func:`np.concatenate <numpy.concatenate>`.
  
      See its docstring for more information.
      """
      # Note: the function name is different here
      return np.concatenate(arrays, axis=axis)
  
  def expand_dims(x: array, axis: int, /) -> array:
      """
      Array API compatible wrapper for :py:func:`np.expand_dims <numpy.expand_dims>`.
  
      See its docstring for more information.
      """
      return np.expand_dims._implementation(x, axis)
  
  def flip(x: array, /, *, axis: Optional[Union[int, Tuple[int, ...]]] = None) -> array:
      """
      Array API compatible wrapper for :py:func:`np.flip <numpy.flip>`.
  
      See its docstring for more information.
      """
      return np.flip._implementation(x, axis=axis)
  
  def reshape(x: array, shape: Tuple[int, ...], /) -> array:
      """
      Array API compatible wrapper for :py:func:`np.reshape <numpy.reshape>`.
  
      See its docstring for more information.
      """
      return np.reshape._implementation(x, shape)
  
  def roll(x: array, shift: Union[int, Tuple[int, ...]], /, *, axis: Optional[Union[int, Tuple[int, ...]]] = None) -> array:
      """
      Array API compatible wrapper for :py:func:`np.roll <numpy.roll>`.
  
      See its docstring for more information.
      """
      return np.roll._implementation(x, shift, axis=axis)
  
  def squeeze(x: array, /, *, axis: Optional[Union[int, Tuple[int, ...]]] = None) -> array:
      """
      Array API compatible wrapper for :
  
  [... the rest is omitted ...]
files: numpy/_array_api/_manipulation_functions.py
files: from __future__ import annotations
  
  from ._types import Optional, Tuple, Union, array
  
  import numpy as np
  
  def concat(arrays: Tuple[array], /, *, axis: Optional[int] = 0) -> array:
      """
      Array API compatible wrapper for :py:func:`np.concatenate <numpy.concatenate>`.
  
      See its docstring for more information.
      """
      # Note: the function name is different here
      return np.concatenate(arrays, axis=axis)
  
  def expand_dims(x: array, axis: int, /) -> array:
      """
      Array API compatible wrapper for :py:func:`np.expand_dims <numpy.expand_dims>`.
  
      See its docstring for more information.
      """
      return np.expand_dims(x, axis)
  
  def flip(x: array, /, *, axis: Optional[Union[int, Tuple[int, ...]]] = None) -> array:
      """
      Array API compatible wrapper for :py:func:`np.flip <numpy.flip>`.
  
      See its docstring for more information.
      """
      return np.flip(x, axis=axis)
  
  def reshape(x: array, shape: Tuple[int, ...], /) -> array:
      """
      Array API compatible wrapper for :py:func:`np.reshape <numpy.reshape>`.
  
      See its docstring for more information.
      """
      return np.reshape(x, shape)
  
  def roll(x: array, shift: Union[int, Tuple[int, ...]], /, *, axis: Optional[Union[int, Tuple[int, ...]]] = None) -> array:
      """
      Array API compatible wrapper for :py:func:`np.roll <numpy.roll>`.
  
      See its docstring for more information.
      """
      return np.roll(x, shift, axis=axis)
  
  def squeeze(x: array, /, *, axis: Optional[Union[int, Tuple[int, ...]]] = None) -> array:
      """
      Array API compatible wrapper for :py:func:`np.squeeze
  
  [... the rest is omitted ...]
files: numpy/_array_api/_manipulation_functions.py
files: from __future__ import annotations
  
  from ._types import Tuple, array
  
  import numpy as np
  
  def argmax(x: array, /, *, axis: int = None, keepdims: bool = False) -> array:
      """
      Array API compatible wrapper for :py:func:`np.argmax <numpy.argmax>`.
  
      See its docstring for more information.
      """
      # Note: this currently fails as np.argmax does not implement keepdims
      return np.asarray(np.argmax._implementation(x, axis=axis, keepdims=keepdims))
  
  def argmin(x: array, /, *, axis: int = None, keepdims: bool = False) -> array:
      """
      Array API compatible wrapper for :py:func:`np.argmin <numpy.argmin>`.
  
      See its docstring for more information.
      """
      # Note: this currently fails as np.argmin does not implement keepdims
      return np.asarray(np.argmin._implementation(x, axis=axis, keepdims=keepdims))
  
  def nonzero(x: array, /) -> Tuple[array, ...]:
      """
      Array API compatible wrapper for :py:func:`np.nonzero <numpy.nonzero>`.
  
      See its docstring for more information.
      """
      return np.nonzero._implementation(x)
  
  def where(condition: array, x1: array, x2: array, /) -> array:
      """
      Array API compatible wrapper for :py:func:`np.where <numpy.where>`.
  
      See its docstring for more information.
      """
      return np.where._implementation(condition, x1, x2)
  
  
  [... the rest is omitted ...]
files: numpy/_array_api/_searching_functions.py
files: from __future__ import annotations
  
  from ._types import Tuple, array
  
  import numpy as np
  
  def argmax(x: array, /, *, axis: int = None, keepdims: bool = False) -> array:
      """
      Array API compatible wrapper for :py:func:`np.argmax <numpy.argmax>`.
  
      See its docstring for more information.
      """
      # Note: this currently fails as np.argmax does not implement keepdims
      return np.asarray(np.argmax(x, axis=axis, keepdims=keepdims))
  
  def argmin(x: array, /, *, axis: int = None, keepdims: bool = False) -> array:
      """
      Array API compatible wrapper for :py:func:`np.argmin <numpy.argmin>`.
  
      See its docstring for more information.
      """
      # Note: this currently fails as np.argmin does not implement keepdims
      return np.asarray(np.argmin(x, axis=axis, keepdims=keepdims))
  
  def nonzero(x: array, /) -> Tuple[array, ...]:
      """
      Array API compatible wrapper for :py:func:`np.nonzero <numpy.nonzero>`.
  
      See its docstring for more information.
      """
      return np.nonzero(x)
  
  def where(condition: array, x1: array, x2: array, /) -> array:
      """
      Array API compatible wrapper for :py:func:`np.where <numpy.where>`.
  
      See its docstring for more information.
      """
      return np.where(condition, x1, x2)
  
  
  [... the rest is omitted ...]
files: numpy/_array_api/_searching_functions.py
files: from __future__ import annotations
  
  from ._types import Tuple, Union, array
  
  import numpy as np
  
  def unique(x: array, /, *, return_counts: bool = False, return_index: bool = False, return_inverse: bool = False, sorted: bool = True) -> Union[array, Tuple[array, ...]]:
      """
      Array API compatible wrapper for :py:func:`np.unique <numpy.unique>`.
  
      See its docstring for more information.
      """
      return np.unique._implementation(x, return_counts=return_counts, return_index=return_index, return_inverse=return_inverse, sorted=sorted)
  
  
  [... the rest is omitted ...]
files: numpy/_array_api/_set_functions.py
files: from __future__ import annotations
  
  from ._types import Tuple, Union, array
  
  import numpy as np
  
  def unique(x: array, /, *, return_counts: bool = False, return_index: bool = False, return_inverse: bool = False, sorted: bool = True) -> Union[array, Tuple[array, ...]]:
      """
      Array API compatible wrapper for :py:func:`np.unique <numpy.unique>`.
  
      See its docstring for more information.
      """
      return np.unique(x, return_counts=return_counts, return_index=return_index, return_inverse=return_inverse, sorted=sorted)
  
  
  [... the rest is omitted ...]
files: numpy/_array_api/_set_functions.py
files: from __future__ import annotations
  
  from ._types import array
  
  import numpy as np
  
  def argsort(x: array, /, *, axis: int = -1, descending: bool = False, stable: bool = True) -> array:
      """
      Array API compatible wrapper for :py:func:`np.argsort <numpy.argsort>`.
  
      See its docstring for more information.
      """
      # Note: this keyword argument is different, and the default is different.
      kind = 'stable' if stable else 'quicksort'
      res = np.argsort._implementation(x, axis=axis, kind=kind)
      if descending:
          res = np.flip(res, axis=axis)
      return res
  
  def sort(x: array, /, *, axis: int = -1, descending: bool = False, stable: bool = True) -> array:
      """
      Array API compatible wrapper for :py:func:`np.sort <numpy.sort>`.
  
      See its docstring for more information.
      """
      # Note: this keyword argument is different, and the default is different.
      kind = 'stable' if stable else 'quicksort'
      res = np.sort._implementation(x, axis=axis, kind=kind)
      if descending:
          res = np.flip(res, axis=axis)
      return res
  
  
  [... the rest is omitted ...]
files: numpy/_array_api/_sorting_functions.py
files: from __future__ import annotations
  
  from ._types import array
  
  import numpy as np
  
  def argsort(x: array, /, *, axis: int = -1, descending: bool = False, stable: bool = True) -> array:
      """
      Array API compatible wrapper for :py:func:`np.argsort <numpy.argsort>`.
  
      See its docstring for more information.
      """
      # Note: this keyword argument is different, and the default is different.
      kind = 'stable' if stable else 'quicksort'
      res = np.argsort(x, axis=axis, kind=kind)
      if descending:
          res = np.flip(res, axis=axis)
      return res
  
  def sort(x: array, /, *, axis: int = -1, descending: bool = False, stable: bool = True) -> array:
      """
      Array API compatible wrapper for :py:func:`np.sort <numpy.sort>`.
  
      See its docstring for more information.
      """
      # Note: this keyword argument is different, and the default is different.
      kind = 'stable' if stable else 'quicksort'
      res = np.sort(x, axis=axis, kind=kind)
      if descending:
          res = np.flip(res, axis=axis)
      return res
  
  
  [... the rest is omitted ...]
files: numpy/_array_api/_sorting_functions.py
files: from __future__ import annotations
  
  from ._types import Optional, Tuple, Union, array
  
  import numpy as np
  
  def max(x: array, /, *, axis: Optional[Union[int, Tuple[int, ...]]] = None, keepdims: bool = False) -> array:
      return np.max._implementation(x, axis=axis, keepdims=keepdims)
  
  def mean(x: array, /, *, axis: Optional[Union[int, Tuple[int, ...]]] = None, keepdims: bool = False) -> array:
      return np.asarray(np.mean._implementation(x, axis=axis, keepdims=keepdims))
  
  def min(x: array, /, *, axis: Optional[Union[int, Tuple[int, ...]]] = None, keepdims: bool = False) -> array:
      return np.min._implementation(x, axis=axis, keepdims=keepdims)
  
  def prod(x: array, /, *, axis: Optional[Union[int, Tuple[int, ...]]] = None, keepdims: bool = False) -> array:
      return np.asarray(np.prod._implementation(x, axis=axis, keepdims=keepdims))
  
  def std(x: array, /, *, axis: Optional[Union[int, Tuple[int, ...]]] = None, correction: Union[int, float] = 0.0, keepdims: bool = False) -> array:
      # Note: the keyword argument correction is different here
      return np.asarray(np.std._implementation(x, axis=axis, ddof=correction, keepdims=keepdims))
  
  def sum(x: array, /, *, axis: Optional[Union[int, Tuple[int, ...]]] = None, keepdims: bool = False) -> array:
      return np.asarray(np.sum._implementation(x, axis=axis, keepdims=keepdims))
  
  def var(x: array, /, *, axis: Optional[Union[int, Tuple[int, ...]]] = None, correction: Union[int, float] = 0.0,
  
  [... the rest is omitted ...]
files: numpy/_array_api/_statistical_functions.py
files: from __future__ import annotations
  
  from ._types import Optional, Tuple, Union, array
  
  import numpy as np
  
  def max(x: array, /, *, axis: Optional[Union[int, Tuple[int, ...]]] = None, keepdims: bool = False) -> array:
      return np.max(x, axis=axis, keepdims=keepdims)
  
  def mean(x: array, /, *, axis: Optional[Union[int, Tuple[int, ...]]] = None, keepdims: bool = False) -> array:
      return np.asarray(np.mean(x, axis=axis, keepdims=keepdims))
  
  def min(x: array, /, *, axis: Optional[Union[int, Tuple[int, ...]]] = None, keepdims: bool = False) -> array:
      return np.min(x, axis=axis, keepdims=keepdims)
  
  def prod(x: array, /, *, axis: Optional[Union[int, Tuple[int, ...]]] = None, keepdims: bool = False) -> array:
      return np.asarray(np.prod(x, axis=axis, keepdims=keepdims))
  
  def std(x: array, /, *, axis: Optional[Union[int, Tuple[int, ...]]] = None, correction: Union[int, float] = 0.0, keepdims: bool = False) -> array:
      # Note: the keyword argument correction is different here
      return np.asarray(np.std(x, axis=axis, ddof=correction, keepdims=keepdims))
  
  def sum(x: array, /, *, axis: Optional[Union[int, Tuple[int, ...]]] = None, keepdims: bool = False) -> array:
      return np.asarray(np.sum(x, axis=axis, keepdims=keepdims))
  
  def var(x: array, /, *, axis: Optional[Union[int, Tuple[int, ...]]] = None, correction: Union[int, float] = 0.0, keepdims: bool = False) -> array:
     
  
  [... the rest is omitted ...]
files: numpy/_array_api/_statistical_functions.py
files: from __future__ import annotations
  
  from ._types import Optional, Tuple, Union, array
  
  import numpy as np
  
  def all(x: array, /, *, axis: Optional[Union[int, Tuple[int, ...]]] = None, keepdims: bool = False) -> array:
      """
      Array API compatible wrapper for :py:func:`np.all <numpy.all>`.
  
      See its docstring for more information.
      """
      return np.asarray(np.all._implementation(x, axis=axis, keepdims=keepdims))
  
  def any(x: array, /, *, axis: Optional[Union[int, Tuple[int, ...]]] = None, keepdims: bool = False) -> array:
      """
      Array API compatible wrapper for :py:func:`np.any <numpy.any>`.
  
      See its docstring for more information.
      """
      return np.asarray(np.any._implementation(x, axis=axis, keepdims=keepdims))
  
  
  [... the rest is omitted ...]
files: numpy/_array_api/_utility_functions.py
files: from __future__ import annotations
  
  from ._types import Optional, Tuple, Union, array
  
  import numpy as np
  
  def all(x: array, /, *, axis: Optional[Union[int, Tuple[int, ...]]] = None, keepdims: bool = False) -> array:
      """
      Array API compatible wrapper for :py:func:`np.all <numpy.all>`.
  
      See its docstring for more information.
      """
      return np.asarray(np.all(x, axis=axis, keepdims=keepdims))
  
  def any(x: array, /, *, axis: Optional[Union[int, Tuple[int, ...]]] = None, keepdims: bool = False) -> array:
      """
      Array API compatible wrapper for :py:func:`np.any <numpy.any>`.
  
      See its docstring for more information.
      """
      return np.asarray(np.any(x, axis=axis, keepdims=keepdims))
  
  
  [... the rest is omitted ...]
files: numpy/_array_api/_utility_functions.py