code: def lexsort(keys, axis=None):
      """
      lexsort(keys, axis=-1)
  
      Perform an indirect stable sort using a sequence of keys.
  
      Given multiple sorting keys, which can be interpreted as columns in a
      spreadsheet, lexsort returns an array of integer indices that describes
      the sort order by multiple columns. The last key in the sequence is used
      for the primary sort order, the second-to-last key for the secondary sort
      order, and so on. The keys argument must be a sequence of objects that
      can be converted to arrays of the same shape. If a 2D array is provided
      for the keys argument, its rows are interpreted as the sorting keys and
      sorting is according to the last row, second last row etc.
  
      Parameters
      ----------
      keys : (k, N) array or tuple containing k (N,)-shaped sequences
          The `k` different "columns" to be sorted.  The last column (or row if
          `keys` is a 2D array) is the primary sort key.
      axis : int, optional
          Axis to be indirectly sorted.  By default, sort over the last axis.
  
      Returns
      -------
      indices : (N,) ndarray of ints
          Array of indices that sort the keys along the specified axis.
  
      See Also
      --------
      argsort : Indirect sort.
      ndarray.sort : In-place sort.
      sort : Return a sorted copy of an array.
  
      Examples
      --------
      Sort names: first by surname, then by name.
  
      >>> surnames =    ('Hertz',    'Galilei', 'Hertz')
      >>> first_names = ('Heinrich', 'Galileo', 'Gustav')
      >>> ind = np.lexsort((first_names, surnames))
      >>> ind
      array([1, 2, 0])
  
      >>> [surnames[i] + ", " + first_names[i] for i in ind]
      ['Galilei, Galileo', 'Hertz, Gustav', 'Hertz, Heinrich']
  
      Sort two columns of numbers:
  
      >>> a = [1,5,1,4,3,4,4] # First column
      >>> b = [9,4,0,4,0,2,1] # Second column
      >>> ind = np.lexsort((b,a)) # Sort by a, then by b
      >>> ind
      array([2, 0, 4, 6, 5, 3, 1])
  
      >>> [(a[i],b[i]) for i in ind]
      [(1, 0), (1, 9), (3, 0), (4, 1), (4, 2), (4, 4), (5, 4)]
  
      Note that sorting is first according to the elements of ``a``.
      Secondary sorting is according to the elements of ``b``.
  
      A normal ``argsort`` would have yielded:
  
      >>> [(a[i],b[i]) for i in np.argsort(a)]
      [(1, 9), (1, 0), (3, 0), (4, 4), (4, 2), (4, 1), (5, 4)]
  
      Structured arrays are sorted lexically by ``argsort``:
  
      >>> x = np.array([(1,9), (5,4), (1,0), (4,4), (3,0), (4,2), (4,1)],
      ...              dtype=np.dtype([('x', int), ('y', int)]))
  
      >>> np.argsort(x) # or np.argsort(x, order=('x', 'y'))
      array([2, 0, 4, 6, 5, 3, 1])
  
      """
      if isinstance(keys, tuple):
          return keys
      else:
          return (keys,)
  
imports: import functools
  from .None import overrides
  from .None import _multiarray_umath
  from ._multiarray_umath import *
  from ._multiarray_umath import fastCopyAndTranspose, _flagdict, from_dlpack, _place, _reconstruct, _vec_string, _ARRAY_API, _monotonicity, _get_ndarray_c_version, _get_madvise_hugepage, _set_madvise_hugepage, _get_promotion_state, _set_promotion_state, _using_numpy2_behavior
label_desc: Use image node_id 5 for calling a global function with example usage: lexsort(keys, axis) and returns: keys, keys