code: def array(
      obj,
      dtype=None,
      copy=True,
      order="K",
      subok=False,
      ndmin=0,
      *,
      blocking=False,
  ):
      """Creates an array on the current device.
  
      This function currently does not support the ``subok`` option.
  
      Args:
          obj: :class:`cupy.ndarray` object or any other object that can be
              passed to :func:`numpy.array`.
          dtype: Data type specifier.
          copy (bool): If ``False``, this function returns ``obj`` if possible.
              Otherwise this function always returns a new array.
          order ({'C', 'F', 'A', 'K'}): Row-major (C-style) or column-major
              (Fortran-style) order.
              When ``order`` is ``'A'``, it uses ``'F'`` if ``a`` is column-major
              and uses ``'C'`` otherwise.
              And when ``order`` is ``'K'``, it keeps strides as closely as
              possible.
              If ``obj`` is :class:`numpy.ndarray`, the function returns ``'C'``
              or ``'F'`` order array.
          subok (bool): If ``True``, then sub-classes will be passed-through,
              otherwise the returned array will be forced to be a base-class
              array (default).
          ndmin (int): Minimum number of dimensions. Ones are inserted to the
              head of the shape if needed.
          blocking (bool): Default is ``False``, meaning if a H2D copy is needed
              it would run asynchronously on the current stream, and users are
              responsible for ensuring the stream order. For example, writing to
              the source ``obj`` without proper ordering while copying would
              result in a race condition. If set to ``True``, the copy is
              synchronous (with respect to the host).
  
      Returns:
          cupy.ndarray: An array on the current device.
  
      .. note::
         This method currently does not support ``subok`` argument.
  
      .. note::
         If ``obj`` is an `numpy.ndarray` instance that contains big-endian data,
         this function automatically swaps its byte order to little-endian,
         which is the NVIDIA and AMD GPU architecture's native use.
  
      .. seealso:: :func:`numpy.array`
  
      """
      return _core.array(
          obj, dtype, copy, order, subok, ndmin, blocking
      )
  
file_path: cupy/cupy/_creation/from_data.py
imports: import numpy
  from cupy import _core
  from cupy._core import fusion
label_desc: Use image node_id 1 for calling a global function with example usage: array(obj, dtype, copy, order, subok, ndmin) and returns: _core