code: def eye(N, M=None, k=0, dtype=float, order="C", *, like=None):
      """
      Return a 2-D array with ones on the diagonal and zeros elsewhere.
  
      Parameters
      ----------
      N : int
        Number of rows in the output.
      M : int, optional
        Number of columns in the output. If None, defaults to `N`.
      k : int, optional
        Index of the diagonal: 0 (the default) refers to the main diagonal,
        a positive value refers to an upper diagonal, and a negative value
        to a lower diagonal.
      dtype : data-type, optional
        Data-type of the returned array.
      order : {'C', 'F'}, optional
          Whether the output should be stored in row-major (C-style) or
          column-major (Fortran-style) order in memory.
  
          .. versionadded:: 1.14.0
      ${ARRAY_FUNCTION_LIKE}
  
          .. versionadded:: 1.20.0
  
      Returns
      -------
      I : ndarray of shape (N,M)
        An array where all elements are equal to zero, except for the `k`-th
        diagonal, whose values are equal to one.
  
      See Also
      --------
      identity : (almost) equivalent function
      diag : diagonal 2-D array from a 1-D array specified by the user.
  
      Examples
      --------
      >>> np.eye(2, dtype=int)
      array([[1, 0],
             [0, 1]])
      >>> np.eye(3, k=1)
      array([[0.,  1.,  0.],
             [0.,  0.,  1.],
             [0.,  0.,  0.]])
  
      """
      if like is not None:
          return _eye_with_like(
              like, N, M=M, k=k, dtype=dtype, order=order
          )
      if M is None:
          M = N
      m = zeros((N, M), dtype=dtype, order=order)
      if k >= M:
          return m
      # Ensure M and k are integers, so we don't get any surprise casting
      # results in the expressions `M-k` and `M+1` used below.  This avoids
      # a problem with inputs with type (for example) np.uint64.
      M = operator.index(M)
      k = operator.index(k)
      if k >= 0:
          i = k
      else:
          i = (-k) * M
      m[: M - k].flat[i :: M + 1] = 1
      return m
  
imports: import functools
  import operator
  from numpy.core.numeric import asanyarray, arange, zeros, greater_equal, multiply, ones, asarray, where, int8, int16, int32, int64, intp, empty, promote_types, diagonal, nonzero, indices
  from numpy.core.overrides import set_array_function_like_doc, set_module
  from numpy.core import overrides
  from numpy.core import iinfo
  from numpy.lib.stride_tricks import broadcast_to
label_desc: Use image node_id 5 for calling a global function with example usage: eye(N, M, k, dtype, order) and returns: m, _eye_with_like, m