code: def shuffle(*arrays, **options):
      arrays = [convert_to_tensor_or_dataframe(ar) for ar in arrays]
      axes = options.pop("axes", (0,))
      if not isinstance(axes, Iterable):
          axes = (axes,)
      elif not isinstance(axes, tuple):
          axes = tuple(axes)
      random_state = check_random_state(
          options.pop("random_state", None)
      ).to_numpy()
      if options:
          raise TypeError(
              f"shuffle() got an unexpected keyword argument {next(iter(options))}"
          )
  
      max_ndim = max(ar.ndim for ar in arrays)
      axes = tuple(
          np.unique(
              [validate_axis(max_ndim, ax) for ax in axes]
          ).tolist()
      )
      seeds = gen_random_seeds(len(axes), random_state)
  
      # verify shape
      for ax in axes:
          shapes = {ar.shape[ax] for ar in arrays if ax < ar.ndim}
          if len(shapes) > 1:
              raise ValueError(
                  f"arrays do not have same shape on axis {ax}"
              )
  
      op = LearnShuffle(
          axes=axes, seeds=seeds, output_types=get_output_types(*arrays)
      )
      shuffled_arrays = op(arrays)
      if len(arrays) == 1:
          return shuffled_arrays[0]
      else:
          return ExecutableTuple(shuffled_arrays)
  
imports: import itertools
  from collections import defaultdict
  from collections.abc import Iterable
  from functools import reduce
  import numpy
  import pandas
  from ...None import opcodes
  from ...core import get_output_types, recursive_tile
  from ...core.operand import OperandStage, MapReduceOperand
  from ...dataframe.utils import parse_index
  from ...lib import sparse
  from ...serialization.serializables import FieldTypes, TupleField, KeyField
  from ...tensor.utils import validate_axis, check_random_state, gen_random_seeds, decide_unify_split
  from ...tensor.array_utils import get_array_module
  from ...utils import tokenize, lazy_import, has_unknown_shape
  from ...core import ExecutableTuple
  from ..operands import LearnOperandMixin, OutputType, LearnShuffleProxy
  from ..utils import convert_to_tensor_or_dataframe
label_desc: Use image node_id 3 for calling a global function with example usage: shuffle() and returns: shuffled_arrays, ExecutableTuple